clang  15.0.0git
altivec.h
Go to the documentation of this file.
1 /*===---- altivec.h - Standard header for type generic math ---------------===*\
2  *
3  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4  * See https://llvm.org/LICENSE.txt for license information.
5  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6  *
7 \*===----------------------------------------------------------------------===*/
8 
9 #ifndef __ALTIVEC_H
10 #define __ALTIVEC_H
11 
12 #ifndef __ALTIVEC__
13 #error "AltiVec support not enabled"
14 #endif
15 
16 /* Constants for mapping CR6 bits to predicate result. */
17 
18 #define __CR6_EQ 0
19 #define __CR6_EQ_REV 1
20 #define __CR6_LT 2
21 #define __CR6_LT_REV 3
22 #define __CR6_GT 4
23 #define __CR6_GT_REV 5
24 #define __CR6_SO 6
25 #define __CR6_SO_REV 7
26 
27 /* Constants for vec_test_data_class */
28 #define __VEC_CLASS_FP_SUBNORMAL_N (1 << 0)
29 #define __VEC_CLASS_FP_SUBNORMAL_P (1 << 1)
30 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
31  __VEC_CLASS_FP_SUBNORMAL_N)
32 #define __VEC_CLASS_FP_ZERO_N (1<<2)
33 #define __VEC_CLASS_FP_ZERO_P (1<<3)
34 #define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P | \
35  __VEC_CLASS_FP_ZERO_N)
36 #define __VEC_CLASS_FP_INFINITY_N (1<<4)
37 #define __VEC_CLASS_FP_INFINITY_P (1<<5)
38 #define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P | \
39  __VEC_CLASS_FP_INFINITY_N)
40 #define __VEC_CLASS_FP_NAN (1<<6)
41 #define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN | \
42  __VEC_CLASS_FP_SUBNORMAL | \
43  __VEC_CLASS_FP_ZERO | \
44  __VEC_CLASS_FP_INFINITY)
45 
46 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
47 
48 #include <stddef.h>
49 
50 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
51  vector signed char __a, vector signed char __b, vector unsigned char __c);
52 
53 static __inline__ vector unsigned char __ATTRS_o_ai
54 vec_perm(vector unsigned char __a, vector unsigned char __b,
55  vector unsigned char __c);
56 
57 static __inline__ vector bool char __ATTRS_o_ai
58 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
59 
60 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
61  vector signed short __b,
62  vector unsigned char __c);
63 
64 static __inline__ vector unsigned short __ATTRS_o_ai
65 vec_perm(vector unsigned short __a, vector unsigned short __b,
66  vector unsigned char __c);
67 
68 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
69  vector bool short __a, vector bool short __b, vector unsigned char __c);
70 
71 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
72  vector pixel __b,
73  vector unsigned char __c);
74 
75 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
76  vector signed int __b,
77  vector unsigned char __c);
78 
79 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
80  vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
81 
82 static __inline__ vector bool int __ATTRS_o_ai
83 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
84 
85 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
86  vector float __b,
87  vector unsigned char __c);
88 
89 #ifdef __VSX__
90 static __inline__ vector long long __ATTRS_o_ai
91 vec_perm(vector signed long long __a, vector signed long long __b,
92  vector unsigned char __c);
93 
94 static __inline__ vector unsigned long long __ATTRS_o_ai
95 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
96  vector unsigned char __c);
97 
98 static __inline__ vector bool long long __ATTRS_o_ai
99 vec_perm(vector bool long long __a, vector bool long long __b,
100  vector unsigned char __c);
101 
102 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
103  vector double __b,
104  vector unsigned char __c);
105 #endif
106 
107 static __inline__ vector unsigned char __ATTRS_o_ai
108 vec_xor(vector unsigned char __a, vector unsigned char __b);
109 
110 /* vec_abs */
111 
112 #define __builtin_altivec_abs_v16qi vec_abs
113 #define __builtin_altivec_abs_v8hi vec_abs
114 #define __builtin_altivec_abs_v4si vec_abs
115 
116 static __inline__ vector signed char __ATTRS_o_ai
117 vec_abs(vector signed char __a) {
118  return __builtin_altivec_vmaxsb(__a, -__a);
119 }
120 
121 static __inline__ vector signed short __ATTRS_o_ai
122 vec_abs(vector signed short __a) {
123  return __builtin_altivec_vmaxsh(__a, -__a);
124 }
125 
126 static __inline__ vector signed int __ATTRS_o_ai
127 vec_abs(vector signed int __a) {
128  return __builtin_altivec_vmaxsw(__a, -__a);
129 }
130 
131 #ifdef __POWER8_VECTOR__
132 static __inline__ vector signed long long __ATTRS_o_ai
133 vec_abs(vector signed long long __a) {
134  return __builtin_altivec_vmaxsd(__a, -__a);
135 }
136 #endif
137 
138 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
139 #ifdef __VSX__
140  return __builtin_vsx_xvabssp(__a);
141 #else
142  vector unsigned int __res =
143  (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
144  return (vector float)__res;
145 #endif
146 }
147 
148 #ifdef __VSX__
149 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
150  return __builtin_vsx_xvabsdp(__a);
151 }
152 #endif
153 
154 /* vec_abss */
155 #define __builtin_altivec_abss_v16qi vec_abss
156 #define __builtin_altivec_abss_v8hi vec_abss
157 #define __builtin_altivec_abss_v4si vec_abss
158 
159 static __inline__ vector signed char __ATTRS_o_ai
160 vec_abss(vector signed char __a) {
161  return __builtin_altivec_vmaxsb(
162  __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
163 }
164 
165 static __inline__ vector signed short __ATTRS_o_ai
166 vec_abss(vector signed short __a) {
167  return __builtin_altivec_vmaxsh(
168  __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
169 }
170 
171 static __inline__ vector signed int __ATTRS_o_ai
172 vec_abss(vector signed int __a) {
173  return __builtin_altivec_vmaxsw(
174  __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
175 }
176 
177 /* vec_absd */
178 #if defined(__POWER9_VECTOR__)
179 
180 static __inline__ vector unsigned char __ATTRS_o_ai
181 vec_absd(vector unsigned char __a, vector unsigned char __b) {
182  return __builtin_altivec_vabsdub(__a, __b);
183 }
184 
185 static __inline__ vector unsigned short __ATTRS_o_ai
186 vec_absd(vector unsigned short __a, vector unsigned short __b) {
187  return __builtin_altivec_vabsduh(__a, __b);
188 }
189 
190 static __inline__ vector unsigned int __ATTRS_o_ai
191 vec_absd(vector unsigned int __a, vector unsigned int __b) {
192  return __builtin_altivec_vabsduw(__a, __b);
193 }
194 
195 #endif /* End __POWER9_VECTOR__ */
196 
197 /* vec_add */
198 
199 static __inline__ vector signed char __ATTRS_o_ai
200 vec_add(vector signed char __a, vector signed char __b) {
201  return __a + __b;
202 }
203 
204 static __inline__ vector signed char __ATTRS_o_ai
205 vec_add(vector bool char __a, vector signed char __b) {
206  return (vector signed char)__a + __b;
207 }
208 
209 static __inline__ vector signed char __ATTRS_o_ai
210 vec_add(vector signed char __a, vector bool char __b) {
211  return __a + (vector signed char)__b;
212 }
213 
214 static __inline__ vector unsigned char __ATTRS_o_ai
215 vec_add(vector unsigned char __a, vector unsigned char __b) {
216  return __a + __b;
217 }
218 
219 static __inline__ vector unsigned char __ATTRS_o_ai
220 vec_add(vector bool char __a, vector unsigned char __b) {
221  return (vector unsigned char)__a + __b;
222 }
223 
224 static __inline__ vector unsigned char __ATTRS_o_ai
225 vec_add(vector unsigned char __a, vector bool char __b) {
226  return __a + (vector unsigned char)__b;
227 }
228 
229 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
230  vector short __b) {
231  return __a + __b;
232 }
233 
234 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
235  vector short __b) {
236  return (vector short)__a + __b;
237 }
238 
239 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
240  vector bool short __b) {
241  return __a + (vector short)__b;
242 }
243 
244 static __inline__ vector unsigned short __ATTRS_o_ai
245 vec_add(vector unsigned short __a, vector unsigned short __b) {
246  return __a + __b;
247 }
248 
249 static __inline__ vector unsigned short __ATTRS_o_ai
250 vec_add(vector bool short __a, vector unsigned short __b) {
251  return (vector unsigned short)__a + __b;
252 }
253 
254 static __inline__ vector unsigned short __ATTRS_o_ai
255 vec_add(vector unsigned short __a, vector bool short __b) {
256  return __a + (vector unsigned short)__b;
257 }
258 
259 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
260  vector int __b) {
261  return __a + __b;
262 }
263 
264 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
265  vector int __b) {
266  return (vector int)__a + __b;
267 }
268 
269 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
270  vector bool int __b) {
271  return __a + (vector int)__b;
272 }
273 
274 static __inline__ vector unsigned int __ATTRS_o_ai
275 vec_add(vector unsigned int __a, vector unsigned int __b) {
276  return __a + __b;
277 }
278 
279 static __inline__ vector unsigned int __ATTRS_o_ai
280 vec_add(vector bool int __a, vector unsigned int __b) {
281  return (vector unsigned int)__a + __b;
282 }
283 
284 static __inline__ vector unsigned int __ATTRS_o_ai
285 vec_add(vector unsigned int __a, vector bool int __b) {
286  return __a + (vector unsigned int)__b;
287 }
288 
289 #ifdef __POWER8_VECTOR__
290 static __inline__ vector signed long long __ATTRS_o_ai
291 vec_add(vector signed long long __a, vector signed long long __b) {
292  return __a + __b;
293 }
294 
295 static __inline__ vector unsigned long long __ATTRS_o_ai
296 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
297  return __a + __b;
298 }
299 
300 #ifdef __SIZEOF_INT128__
301 static __inline__ vector signed __int128 __ATTRS_o_ai
302 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
303  return __a + __b;
304 }
305 
306 static __inline__ vector unsigned __int128 __ATTRS_o_ai
307 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
308  return __a + __b;
309 }
310 #endif
311 
312 static __inline__ vector unsigned char __attribute__((__always_inline__))
313 vec_add_u128(vector unsigned char __a, vector unsigned char __b) {
314  return __builtin_altivec_vadduqm(__a, __b);
315 }
316 #elif defined(__VSX__)
317 static __inline__ vector signed long long __ATTRS_o_ai
318 vec_add(vector signed long long __a, vector signed long long __b) {
319 #ifdef __LITTLE_ENDIAN__
320  // Little endian systems on CPU's prior to Power8 don't really exist
321  // so scalarizing is fine.
322  return __a + __b;
323 #else
324  vector unsigned int __res =
325  (vector unsigned int)__a + (vector unsigned int)__b;
326  vector unsigned int __carry = __builtin_altivec_vaddcuw(
327  (vector unsigned int)__a, (vector unsigned int)__b);
328  __carry = __builtin_shufflevector((vector unsigned char)__carry,
329  (vector unsigned char)__carry, 0, 0, 0, 7,
330  0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0);
331  return (vector signed long long)(__res + __carry);
332 #endif
333 }
334 
335 static __inline__ vector unsigned long long __ATTRS_o_ai
336 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
337  return (vector unsigned long long)vec_add((vector signed long long)__a,
338  (vector signed long long)__b);
339 }
340 #endif // __POWER8_VECTOR__
341 
342 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
343  vector float __b) {
344  return __a + __b;
345 }
346 
347 #ifdef __VSX__
348 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
349  vector double __b) {
350  return __a + __b;
351 }
352 #endif // __VSX__
353 
354 /* vec_adde */
355 
356 #ifdef __POWER8_VECTOR__
357 #ifdef __SIZEOF_INT128__
358 static __inline__ vector signed __int128 __ATTRS_o_ai
359 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
360  vector signed __int128 __c) {
361  return __builtin_altivec_vaddeuqm(__a, __b, __c);
362 }
363 
364 static __inline__ vector unsigned __int128 __ATTRS_o_ai
365 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
366  vector unsigned __int128 __c) {
367  return __builtin_altivec_vaddeuqm(__a, __b, __c);
368 }
369 #endif
370 
371 static __inline__ vector unsigned char __attribute__((__always_inline__))
372 vec_adde_u128(vector unsigned char __a, vector unsigned char __b,
373  vector unsigned char __c) {
374  return (vector unsigned char)__builtin_altivec_vaddeuqm(__a, __b, __c);
375 }
376 #endif
377 
378 static __inline__ vector signed int __ATTRS_o_ai
379 vec_adde(vector signed int __a, vector signed int __b,
380  vector signed int __c) {
381  vector signed int __mask = {1, 1, 1, 1};
382  vector signed int __carry = __c & __mask;
383  return vec_add(vec_add(__a, __b), __carry);
384 }
385 
386 static __inline__ vector unsigned int __ATTRS_o_ai
387 vec_adde(vector unsigned int __a, vector unsigned int __b,
388  vector unsigned int __c) {
389  vector unsigned int __mask = {1, 1, 1, 1};
390  vector unsigned int __carry = __c & __mask;
391  return vec_add(vec_add(__a, __b), __carry);
392 }
393 
394 /* vec_addec */
395 
396 #ifdef __POWER8_VECTOR__
397 #ifdef __SIZEOF_INT128__
398 static __inline__ vector signed __int128 __ATTRS_o_ai
399 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
400  vector signed __int128 __c) {
401  return __builtin_altivec_vaddecuq(__a, __b, __c);
402 }
403 
404 static __inline__ vector unsigned __int128 __ATTRS_o_ai
405 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
406  vector unsigned __int128 __c) {
407  return __builtin_altivec_vaddecuq(__a, __b, __c);
408 }
409 #endif
410 
411 static __inline__ vector unsigned char __attribute__((__always_inline__))
412 vec_addec_u128(vector unsigned char __a, vector unsigned char __b,
413  vector unsigned char __c) {
414  return (vector unsigned char)__builtin_altivec_vaddecuq(__a, __b, __c);
415 }
416 
417 #ifdef __powerpc64__
418 static __inline__ vector signed int __ATTRS_o_ai
419 vec_addec(vector signed int __a, vector signed int __b,
420  vector signed int __c) {
421 
422  signed int __result[4];
423  for (int i = 0; i < 4; i++) {
424  unsigned int __tempa = (unsigned int) __a[i];
425  unsigned int __tempb = (unsigned int) __b[i];
426  unsigned int __tempc = (unsigned int) __c[i];
427  __tempc = __tempc & 0x00000001;
428  unsigned long long __longa = (unsigned long long) __tempa;
429  unsigned long long __longb = (unsigned long long) __tempb;
430  unsigned long long __longc = (unsigned long long) __tempc;
431  unsigned long long __sum = __longa + __longb + __longc;
432  unsigned long long __res = (__sum >> 32) & 0x01;
433  unsigned long long __tempres = (unsigned int) __res;
434  __result[i] = (signed int) __tempres;
435  }
436 
437  vector signed int ret = { __result[0], __result[1], __result[2], __result[3] };
438  return ret;
439 }
440 
441 static __inline__ vector unsigned int __ATTRS_o_ai
442 vec_addec(vector unsigned int __a, vector unsigned int __b,
443  vector unsigned int __c) {
444 
445  unsigned int __result[4];
446  for (int i = 0; i < 4; i++) {
447  unsigned int __tempc = __c[i] & 1;
448  unsigned long long __longa = (unsigned long long) __a[i];
449  unsigned long long __longb = (unsigned long long) __b[i];
450  unsigned long long __longc = (unsigned long long) __tempc;
451  unsigned long long __sum = __longa + __longb + __longc;
452  unsigned long long __res = (__sum >> 32) & 0x01;
453  unsigned long long __tempres = (unsigned int) __res;
454  __result[i] = (signed int) __tempres;
455  }
456 
457  vector unsigned int ret = { __result[0], __result[1], __result[2], __result[3] };
458  return ret;
459 }
460 #endif // __powerpc64__
461 #endif // __POWER8_VECTOR__
462 
463 /* vec_vaddubm */
464 
465 #define __builtin_altivec_vaddubm vec_vaddubm
466 
467 static __inline__ vector signed char __ATTRS_o_ai
468 vec_vaddubm(vector signed char __a, vector signed char __b) {
469  return __a + __b;
470 }
471 
472 static __inline__ vector signed char __ATTRS_o_ai
473 vec_vaddubm(vector bool char __a, vector signed char __b) {
474  return (vector signed char)__a + __b;
475 }
476 
477 static __inline__ vector signed char __ATTRS_o_ai
478 vec_vaddubm(vector signed char __a, vector bool char __b) {
479  return __a + (vector signed char)__b;
480 }
481 
482 static __inline__ vector unsigned char __ATTRS_o_ai
483 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
484  return __a + __b;
485 }
486 
487 static __inline__ vector unsigned char __ATTRS_o_ai
488 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
489  return (vector unsigned char)__a + __b;
490 }
491 
492 static __inline__ vector unsigned char __ATTRS_o_ai
493 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
494  return __a + (vector unsigned char)__b;
495 }
496 
497 /* vec_vadduhm */
498 
499 #define __builtin_altivec_vadduhm vec_vadduhm
500 
501 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
502  vector short __b) {
503  return __a + __b;
504 }
505 
506 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
507  vector short __b) {
508  return (vector short)__a + __b;
509 }
510 
511 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
512  vector bool short __b) {
513  return __a + (vector short)__b;
514 }
515 
516 static __inline__ vector unsigned short __ATTRS_o_ai
517 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
518  return __a + __b;
519 }
520 
521 static __inline__ vector unsigned short __ATTRS_o_ai
522 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
523  return (vector unsigned short)__a + __b;
524 }
525 
526 static __inline__ vector unsigned short __ATTRS_o_ai
527 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
528  return __a + (vector unsigned short)__b;
529 }
530 
531 /* vec_vadduwm */
532 
533 #define __builtin_altivec_vadduwm vec_vadduwm
534 
535 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
536  vector int __b) {
537  return __a + __b;
538 }
539 
540 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
541  vector int __b) {
542  return (vector int)__a + __b;
543 }
544 
545 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
546  vector bool int __b) {
547  return __a + (vector int)__b;
548 }
549 
550 static __inline__ vector unsigned int __ATTRS_o_ai
551 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
552  return __a + __b;
553 }
554 
555 static __inline__ vector unsigned int __ATTRS_o_ai
556 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
557  return (vector unsigned int)__a + __b;
558 }
559 
560 static __inline__ vector unsigned int __ATTRS_o_ai
561 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
562  return __a + (vector unsigned int)__b;
563 }
564 
565 /* vec_vaddfp */
566 
567 #define __builtin_altivec_vaddfp vec_vaddfp
568 
569 static __inline__ vector float __attribute__((__always_inline__))
570 vec_vaddfp(vector float __a, vector float __b) {
571  return __a + __b;
572 }
573 
574 /* vec_addc */
575 
576 static __inline__ vector signed int __ATTRS_o_ai
577 vec_addc(vector signed int __a, vector signed int __b) {
578  return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
579  (vector unsigned int)__b);
580 }
581 
582 static __inline__ vector unsigned int __ATTRS_o_ai
583 vec_addc(vector unsigned int __a, vector unsigned int __b) {
584  return __builtin_altivec_vaddcuw(__a, __b);
585 }
586 
587 #ifdef __POWER8_VECTOR__
588 #ifdef __SIZEOF_INT128__
589 static __inline__ vector signed __int128 __ATTRS_o_ai
590 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
591  return (vector signed __int128)__builtin_altivec_vaddcuq(
592  (vector unsigned __int128)__a, (vector unsigned __int128)__b);
593 }
594 
595 static __inline__ vector unsigned __int128 __ATTRS_o_ai
596 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
597  return __builtin_altivec_vaddcuq(__a, __b);
598 }
599 #endif
600 
601 static __inline__ vector unsigned char __attribute__((__always_inline__))
602 vec_addc_u128(vector unsigned char __a, vector unsigned char __b) {
603  return (vector unsigned char)__builtin_altivec_vaddcuq(__a, __b);
604 }
605 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
606 
607 /* vec_vaddcuw */
608 
609 static __inline__ vector unsigned int __attribute__((__always_inline__))
610 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
611  return __builtin_altivec_vaddcuw(__a, __b);
612 }
613 
614 /* vec_adds */
615 
616 static __inline__ vector signed char __ATTRS_o_ai
617 vec_adds(vector signed char __a, vector signed char __b) {
618  return __builtin_altivec_vaddsbs(__a, __b);
619 }
620 
621 static __inline__ vector signed char __ATTRS_o_ai
622 vec_adds(vector bool char __a, vector signed char __b) {
623  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
624 }
625 
626 static __inline__ vector signed char __ATTRS_o_ai
627 vec_adds(vector signed char __a, vector bool char __b) {
628  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
629 }
630 
631 static __inline__ vector unsigned char __ATTRS_o_ai
632 vec_adds(vector unsigned char __a, vector unsigned char __b) {
633  return __builtin_altivec_vaddubs(__a, __b);
634 }
635 
636 static __inline__ vector unsigned char __ATTRS_o_ai
637 vec_adds(vector bool char __a, vector unsigned char __b) {
638  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
639 }
640 
641 static __inline__ vector unsigned char __ATTRS_o_ai
642 vec_adds(vector unsigned char __a, vector bool char __b) {
643  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
644 }
645 
646 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
647  vector short __b) {
648  return __builtin_altivec_vaddshs(__a, __b);
649 }
650 
651 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
652  vector short __b) {
653  return __builtin_altivec_vaddshs((vector short)__a, __b);
654 }
655 
656 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
657  vector bool short __b) {
658  return __builtin_altivec_vaddshs(__a, (vector short)__b);
659 }
660 
661 static __inline__ vector unsigned short __ATTRS_o_ai
662 vec_adds(vector unsigned short __a, vector unsigned short __b) {
663  return __builtin_altivec_vadduhs(__a, __b);
664 }
665 
666 static __inline__ vector unsigned short __ATTRS_o_ai
667 vec_adds(vector bool short __a, vector unsigned short __b) {
668  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
669 }
670 
671 static __inline__ vector unsigned short __ATTRS_o_ai
672 vec_adds(vector unsigned short __a, vector bool short __b) {
673  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
674 }
675 
676 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
677  vector int __b) {
678  return __builtin_altivec_vaddsws(__a, __b);
679 }
680 
681 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
682  vector int __b) {
683  return __builtin_altivec_vaddsws((vector int)__a, __b);
684 }
685 
686 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
687  vector bool int __b) {
688  return __builtin_altivec_vaddsws(__a, (vector int)__b);
689 }
690 
691 static __inline__ vector unsigned int __ATTRS_o_ai
692 vec_adds(vector unsigned int __a, vector unsigned int __b) {
693  return __builtin_altivec_vadduws(__a, __b);
694 }
695 
696 static __inline__ vector unsigned int __ATTRS_o_ai
697 vec_adds(vector bool int __a, vector unsigned int __b) {
698  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
699 }
700 
701 static __inline__ vector unsigned int __ATTRS_o_ai
702 vec_adds(vector unsigned int __a, vector bool int __b) {
703  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
704 }
705 
706 /* vec_vaddsbs */
707 
708 static __inline__ vector signed char __ATTRS_o_ai
709 vec_vaddsbs(vector signed char __a, vector signed char __b) {
710  return __builtin_altivec_vaddsbs(__a, __b);
711 }
712 
713 static __inline__ vector signed char __ATTRS_o_ai
714 vec_vaddsbs(vector bool char __a, vector signed char __b) {
715  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
716 }
717 
718 static __inline__ vector signed char __ATTRS_o_ai
719 vec_vaddsbs(vector signed char __a, vector bool char __b) {
720  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
721 }
722 
723 /* vec_vaddubs */
724 
725 static __inline__ vector unsigned char __ATTRS_o_ai
726 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
727  return __builtin_altivec_vaddubs(__a, __b);
728 }
729 
730 static __inline__ vector unsigned char __ATTRS_o_ai
731 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
732  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
733 }
734 
735 static __inline__ vector unsigned char __ATTRS_o_ai
736 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
737  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
738 }
739 
740 /* vec_vaddshs */
741 
742 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
743  vector short __b) {
744  return __builtin_altivec_vaddshs(__a, __b);
745 }
746 
747 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
748  vector short __b) {
749  return __builtin_altivec_vaddshs((vector short)__a, __b);
750 }
751 
752 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
753  vector bool short __b) {
754  return __builtin_altivec_vaddshs(__a, (vector short)__b);
755 }
756 
757 /* vec_vadduhs */
758 
759 static __inline__ vector unsigned short __ATTRS_o_ai
760 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
761  return __builtin_altivec_vadduhs(__a, __b);
762 }
763 
764 static __inline__ vector unsigned short __ATTRS_o_ai
765 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
766  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
767 }
768 
769 static __inline__ vector unsigned short __ATTRS_o_ai
770 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
771  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
772 }
773 
774 /* vec_vaddsws */
775 
776 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
777  vector int __b) {
778  return __builtin_altivec_vaddsws(__a, __b);
779 }
780 
781 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
782  vector int __b) {
783  return __builtin_altivec_vaddsws((vector int)__a, __b);
784 }
785 
786 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
787  vector bool int __b) {
788  return __builtin_altivec_vaddsws(__a, (vector int)__b);
789 }
790 
791 /* vec_vadduws */
792 
793 static __inline__ vector unsigned int __ATTRS_o_ai
794 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
795  return __builtin_altivec_vadduws(__a, __b);
796 }
797 
798 static __inline__ vector unsigned int __ATTRS_o_ai
799 vec_vadduws(vector bool int __a, vector unsigned int __b) {
800  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
801 }
802 
803 static __inline__ vector unsigned int __ATTRS_o_ai
804 vec_vadduws(vector unsigned int __a, vector bool int __b) {
805  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
806 }
807 
808 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
809  defined(__SIZEOF_INT128__)
810 /* vec_vadduqm */
811 
812 static __inline__ vector signed __int128 __ATTRS_o_ai
813 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
814  return __a + __b;
815 }
816 
817 static __inline__ vector unsigned __int128 __ATTRS_o_ai
818 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
819  return __a + __b;
820 }
821 
822 /* vec_vaddeuqm */
823 
824 static __inline__ vector signed __int128 __ATTRS_o_ai
825 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
826  vector signed __int128 __c) {
827  return __builtin_altivec_vaddeuqm(__a, __b, __c);
828 }
829 
830 static __inline__ vector unsigned __int128 __ATTRS_o_ai
831 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
832  vector unsigned __int128 __c) {
833  return __builtin_altivec_vaddeuqm(__a, __b, __c);
834 }
835 
836 /* vec_vaddcuq */
837 
838 static __inline__ vector signed __int128 __ATTRS_o_ai
839 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
840  return __builtin_altivec_vaddcuq(__a, __b);
841 }
842 
843 static __inline__ vector unsigned __int128 __ATTRS_o_ai
844 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
845  return __builtin_altivec_vaddcuq(__a, __b);
846 }
847 
848 /* vec_vaddecuq */
849 
850 static __inline__ vector signed __int128 __ATTRS_o_ai
851 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
852  vector signed __int128 __c) {
853  return __builtin_altivec_vaddecuq(__a, __b, __c);
854 }
855 
856 static __inline__ vector unsigned __int128 __ATTRS_o_ai
857 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
858  vector unsigned __int128 __c) {
859  return __builtin_altivec_vaddecuq(__a, __b, __c);
860 }
861 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
862 
863 /* vec_and */
864 
865 #define __builtin_altivec_vand vec_and
866 
867 static __inline__ vector signed char __ATTRS_o_ai
868 vec_and(vector signed char __a, vector signed char __b) {
869  return __a & __b;
870 }
871 
872 static __inline__ vector signed char __ATTRS_o_ai
873 vec_and(vector bool char __a, vector signed char __b) {
874  return (vector signed char)__a & __b;
875 }
876 
877 static __inline__ vector signed char __ATTRS_o_ai
878 vec_and(vector signed char __a, vector bool char __b) {
879  return __a & (vector signed char)__b;
880 }
881 
882 static __inline__ vector unsigned char __ATTRS_o_ai
883 vec_and(vector unsigned char __a, vector unsigned char __b) {
884  return __a & __b;
885 }
886 
887 static __inline__ vector unsigned char __ATTRS_o_ai
888 vec_and(vector bool char __a, vector unsigned char __b) {
889  return (vector unsigned char)__a & __b;
890 }
891 
892 static __inline__ vector unsigned char __ATTRS_o_ai
893 vec_and(vector unsigned char __a, vector bool char __b) {
894  return __a & (vector unsigned char)__b;
895 }
896 
897 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
898  vector bool char __b) {
899  return __a & __b;
900 }
901 
902 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
903  vector short __b) {
904  return __a & __b;
905 }
906 
907 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
908  vector short __b) {
909  return (vector short)__a & __b;
910 }
911 
912 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
913  vector bool short __b) {
914  return __a & (vector short)__b;
915 }
916 
917 static __inline__ vector unsigned short __ATTRS_o_ai
918 vec_and(vector unsigned short __a, vector unsigned short __b) {
919  return __a & __b;
920 }
921 
922 static __inline__ vector unsigned short __ATTRS_o_ai
923 vec_and(vector bool short __a, vector unsigned short __b) {
924  return (vector unsigned short)__a & __b;
925 }
926 
927 static __inline__ vector unsigned short __ATTRS_o_ai
928 vec_and(vector unsigned short __a, vector bool short __b) {
929  return __a & (vector unsigned short)__b;
930 }
931 
932 static __inline__ vector bool short __ATTRS_o_ai
933 vec_and(vector bool short __a, vector bool short __b) {
934  return __a & __b;
935 }
936 
937 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
938  vector int __b) {
939  return __a & __b;
940 }
941 
942 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
943  vector int __b) {
944  return (vector int)__a & __b;
945 }
946 
947 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
948  vector bool int __b) {
949  return __a & (vector int)__b;
950 }
951 
952 static __inline__ vector unsigned int __ATTRS_o_ai
953 vec_and(vector unsigned int __a, vector unsigned int __b) {
954  return __a & __b;
955 }
956 
957 static __inline__ vector unsigned int __ATTRS_o_ai
958 vec_and(vector bool int __a, vector unsigned int __b) {
959  return (vector unsigned int)__a & __b;
960 }
961 
962 static __inline__ vector unsigned int __ATTRS_o_ai
963 vec_and(vector unsigned int __a, vector bool int __b) {
964  return __a & (vector unsigned int)__b;
965 }
966 
967 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
968  vector bool int __b) {
969  return __a & __b;
970 }
971 
972 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
973  vector float __b) {
974  vector unsigned int __res =
975  (vector unsigned int)__a & (vector unsigned int)__b;
976  return (vector float)__res;
977 }
978 
979 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
980  vector float __b) {
981  vector unsigned int __res =
982  (vector unsigned int)__a & (vector unsigned int)__b;
983  return (vector float)__res;
984 }
985 
986 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
987  vector bool int __b) {
988  vector unsigned int __res =
989  (vector unsigned int)__a & (vector unsigned int)__b;
990  return (vector float)__res;
991 }
992 
993 #ifdef __VSX__
994 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
995  vector double __b) {
996  vector unsigned long long __res =
997  (vector unsigned long long)__a & (vector unsigned long long)__b;
998  return (vector double)__res;
999 }
1000 
1001 static __inline__ vector double __ATTRS_o_ai
1002 vec_and(vector double __a, vector bool long long __b) {
1003  vector unsigned long long __res =
1004  (vector unsigned long long)__a & (vector unsigned long long)__b;
1005  return (vector double)__res;
1006 }
1007 
1008 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
1009  vector double __b) {
1010  vector unsigned long long __res =
1011  (vector unsigned long long)__a & (vector unsigned long long)__b;
1012  return (vector double)__res;
1013 }
1014 
1015 static __inline__ vector signed long long __ATTRS_o_ai
1016 vec_and(vector signed long long __a, vector signed long long __b) {
1017  return __a & __b;
1018 }
1019 
1020 static __inline__ vector signed long long __ATTRS_o_ai
1021 vec_and(vector bool long long __a, vector signed long long __b) {
1022  return (vector signed long long)__a & __b;
1023 }
1024 
1025 static __inline__ vector signed long long __ATTRS_o_ai
1026 vec_and(vector signed long long __a, vector bool long long __b) {
1027  return __a & (vector signed long long)__b;
1028 }
1029 
1030 static __inline__ vector unsigned long long __ATTRS_o_ai
1031 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
1032  return __a & __b;
1033 }
1034 
1035 static __inline__ vector unsigned long long __ATTRS_o_ai
1036 vec_and(vector bool long long __a, vector unsigned long long __b) {
1037  return (vector unsigned long long)__a & __b;
1038 }
1039 
1040 static __inline__ vector unsigned long long __ATTRS_o_ai
1041 vec_and(vector unsigned long long __a, vector bool long long __b) {
1042  return __a & (vector unsigned long long)__b;
1043 }
1044 
1045 static __inline__ vector bool long long __ATTRS_o_ai
1046 vec_and(vector bool long long __a, vector bool long long __b) {
1047  return __a & __b;
1048 }
1049 #endif
1050 
1051 /* vec_vand */
1052 
1053 static __inline__ vector signed char __ATTRS_o_ai
1054 vec_vand(vector signed char __a, vector signed char __b) {
1055  return __a & __b;
1056 }
1057 
1058 static __inline__ vector signed char __ATTRS_o_ai
1059 vec_vand(vector bool char __a, vector signed char __b) {
1060  return (vector signed char)__a & __b;
1061 }
1062 
1063 static __inline__ vector signed char __ATTRS_o_ai
1064 vec_vand(vector signed char __a, vector bool char __b) {
1065  return __a & (vector signed char)__b;
1066 }
1067 
1068 static __inline__ vector unsigned char __ATTRS_o_ai
1069 vec_vand(vector unsigned char __a, vector unsigned char __b) {
1070  return __a & __b;
1071 }
1072 
1073 static __inline__ vector unsigned char __ATTRS_o_ai
1074 vec_vand(vector bool char __a, vector unsigned char __b) {
1075  return (vector unsigned char)__a & __b;
1076 }
1077 
1078 static __inline__ vector unsigned char __ATTRS_o_ai
1079 vec_vand(vector unsigned char __a, vector bool char __b) {
1080  return __a & (vector unsigned char)__b;
1081 }
1082 
1083 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
1084  vector bool char __b) {
1085  return __a & __b;
1086 }
1087 
1088 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1089  vector short __b) {
1090  return __a & __b;
1091 }
1092 
1093 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
1094  vector short __b) {
1095  return (vector short)__a & __b;
1096 }
1097 
1098 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1099  vector bool short __b) {
1100  return __a & (vector short)__b;
1101 }
1102 
1103 static __inline__ vector unsigned short __ATTRS_o_ai
1104 vec_vand(vector unsigned short __a, vector unsigned short __b) {
1105  return __a & __b;
1106 }
1107 
1108 static __inline__ vector unsigned short __ATTRS_o_ai
1109 vec_vand(vector bool short __a, vector unsigned short __b) {
1110  return (vector unsigned short)__a & __b;
1111 }
1112 
1113 static __inline__ vector unsigned short __ATTRS_o_ai
1114 vec_vand(vector unsigned short __a, vector bool short __b) {
1115  return __a & (vector unsigned short)__b;
1116 }
1117 
1118 static __inline__ vector bool short __ATTRS_o_ai
1119 vec_vand(vector bool short __a, vector bool short __b) {
1120  return __a & __b;
1121 }
1122 
1123 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1124  vector int __b) {
1125  return __a & __b;
1126 }
1127 
1128 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
1129  vector int __b) {
1130  return (vector int)__a & __b;
1131 }
1132 
1133 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1134  vector bool int __b) {
1135  return __a & (vector int)__b;
1136 }
1137 
1138 static __inline__ vector unsigned int __ATTRS_o_ai
1139 vec_vand(vector unsigned int __a, vector unsigned int __b) {
1140  return __a & __b;
1141 }
1142 
1143 static __inline__ vector unsigned int __ATTRS_o_ai
1144 vec_vand(vector bool int __a, vector unsigned int __b) {
1145  return (vector unsigned int)__a & __b;
1146 }
1147 
1148 static __inline__ vector unsigned int __ATTRS_o_ai
1149 vec_vand(vector unsigned int __a, vector bool int __b) {
1150  return __a & (vector unsigned int)__b;
1151 }
1152 
1153 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1154  vector bool int __b) {
1155  return __a & __b;
1156 }
1157 
1158 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1159  vector float __b) {
1160  vector unsigned int __res =
1161  (vector unsigned int)__a & (vector unsigned int)__b;
1162  return (vector float)__res;
1163 }
1164 
1165 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1166  vector float __b) {
1167  vector unsigned int __res =
1168  (vector unsigned int)__a & (vector unsigned int)__b;
1169  return (vector float)__res;
1170 }
1171 
1172 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1173  vector bool int __b) {
1174  vector unsigned int __res =
1175  (vector unsigned int)__a & (vector unsigned int)__b;
1176  return (vector float)__res;
1177 }
1178 
1179 #ifdef __VSX__
1180 static __inline__ vector signed long long __ATTRS_o_ai
1181 vec_vand(vector signed long long __a, vector signed long long __b) {
1182  return __a & __b;
1183 }
1184 
1185 static __inline__ vector signed long long __ATTRS_o_ai
1186 vec_vand(vector bool long long __a, vector signed long long __b) {
1187  return (vector signed long long)__a & __b;
1188 }
1189 
1190 static __inline__ vector signed long long __ATTRS_o_ai
1191 vec_vand(vector signed long long __a, vector bool long long __b) {
1192  return __a & (vector signed long long)__b;
1193 }
1194 
1195 static __inline__ vector unsigned long long __ATTRS_o_ai
1196 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1197  return __a & __b;
1198 }
1199 
1200 static __inline__ vector unsigned long long __ATTRS_o_ai
1201 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1202  return (vector unsigned long long)__a & __b;
1203 }
1204 
1205 static __inline__ vector unsigned long long __ATTRS_o_ai
1206 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1207  return __a & (vector unsigned long long)__b;
1208 }
1209 
1210 static __inline__ vector bool long long __ATTRS_o_ai
1211 vec_vand(vector bool long long __a, vector bool long long __b) {
1212  return __a & __b;
1213 }
1214 #endif
1215 
1216 /* vec_andc */
1217 
1218 #define __builtin_altivec_vandc vec_andc
1219 
1220 static __inline__ vector signed char __ATTRS_o_ai
1221 vec_andc(vector signed char __a, vector signed char __b) {
1222  return __a & ~__b;
1223 }
1224 
1225 static __inline__ vector signed char __ATTRS_o_ai
1226 vec_andc(vector bool char __a, vector signed char __b) {
1227  return (vector signed char)__a & ~__b;
1228 }
1229 
1230 static __inline__ vector signed char __ATTRS_o_ai
1231 vec_andc(vector signed char __a, vector bool char __b) {
1232  return __a & ~(vector signed char)__b;
1233 }
1234 
1235 static __inline__ vector unsigned char __ATTRS_o_ai
1236 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1237  return __a & ~__b;
1238 }
1239 
1240 static __inline__ vector unsigned char __ATTRS_o_ai
1241 vec_andc(vector bool char __a, vector unsigned char __b) {
1242  return (vector unsigned char)__a & ~__b;
1243 }
1244 
1245 static __inline__ vector unsigned char __ATTRS_o_ai
1246 vec_andc(vector unsigned char __a, vector bool char __b) {
1247  return __a & ~(vector unsigned char)__b;
1248 }
1249 
1250 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1251  vector bool char __b) {
1252  return __a & ~__b;
1253 }
1254 
1255 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1256  vector short __b) {
1257  return __a & ~__b;
1258 }
1259 
1260 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1261  vector short __b) {
1262  return (vector short)__a & ~__b;
1263 }
1264 
1265 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1266  vector bool short __b) {
1267  return __a & ~(vector short)__b;
1268 }
1269 
1270 static __inline__ vector unsigned short __ATTRS_o_ai
1271 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1272  return __a & ~__b;
1273 }
1274 
1275 static __inline__ vector unsigned short __ATTRS_o_ai
1276 vec_andc(vector bool short __a, vector unsigned short __b) {
1277  return (vector unsigned short)__a & ~__b;
1278 }
1279 
1280 static __inline__ vector unsigned short __ATTRS_o_ai
1281 vec_andc(vector unsigned short __a, vector bool short __b) {
1282  return __a & ~(vector unsigned short)__b;
1283 }
1284 
1285 static __inline__ vector bool short __ATTRS_o_ai
1286 vec_andc(vector bool short __a, vector bool short __b) {
1287  return __a & ~__b;
1288 }
1289 
1290 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1291  vector int __b) {
1292  return __a & ~__b;
1293 }
1294 
1295 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1296  vector int __b) {
1297  return (vector int)__a & ~__b;
1298 }
1299 
1300 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1301  vector bool int __b) {
1302  return __a & ~(vector int)__b;
1303 }
1304 
1305 static __inline__ vector unsigned int __ATTRS_o_ai
1306 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1307  return __a & ~__b;
1308 }
1309 
1310 static __inline__ vector unsigned int __ATTRS_o_ai
1311 vec_andc(vector bool int __a, vector unsigned int __b) {
1312  return (vector unsigned int)__a & ~__b;
1313 }
1314 
1315 static __inline__ vector unsigned int __ATTRS_o_ai
1316 vec_andc(vector unsigned int __a, vector bool int __b) {
1317  return __a & ~(vector unsigned int)__b;
1318 }
1319 
1320 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1321  vector bool int __b) {
1322  return __a & ~__b;
1323 }
1324 
1325 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1326  vector float __b) {
1327  vector unsigned int __res =
1328  (vector unsigned int)__a & ~(vector unsigned int)__b;
1329  return (vector float)__res;
1330 }
1331 
1332 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1333  vector float __b) {
1334  vector unsigned int __res =
1335  (vector unsigned int)__a & ~(vector unsigned int)__b;
1336  return (vector float)__res;
1337 }
1338 
1339 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1340  vector bool int __b) {
1341  vector unsigned int __res =
1342  (vector unsigned int)__a & ~(vector unsigned int)__b;
1343  return (vector float)__res;
1344 }
1345 
1346 #ifdef __VSX__
1347 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1348  vector double __b) {
1349  vector unsigned long long __res =
1350  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1351  return (vector double)__res;
1352 }
1353 
1354 static __inline__ vector double __ATTRS_o_ai
1355 vec_andc(vector double __a, vector bool long long __b) {
1356  vector unsigned long long __res =
1357  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1358  return (vector double)__res;
1359 }
1360 
1361 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
1362  vector double __b) {
1363  vector unsigned long long __res =
1364  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1365  return (vector double)__res;
1366 }
1367 
1368 static __inline__ vector signed long long __ATTRS_o_ai
1369 vec_andc(vector signed long long __a, vector signed long long __b) {
1370  return __a & ~__b;
1371 }
1372 
1373 static __inline__ vector signed long long __ATTRS_o_ai
1374 vec_andc(vector bool long long __a, vector signed long long __b) {
1375  return (vector signed long long)__a & ~__b;
1376 }
1377 
1378 static __inline__ vector signed long long __ATTRS_o_ai
1379 vec_andc(vector signed long long __a, vector bool long long __b) {
1380  return __a & ~(vector signed long long)__b;
1381 }
1382 
1383 static __inline__ vector unsigned long long __ATTRS_o_ai
1384 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1385  return __a & ~__b;
1386 }
1387 
1388 static __inline__ vector unsigned long long __ATTRS_o_ai
1389 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1390  return (vector unsigned long long)__a & ~__b;
1391 }
1392 
1393 static __inline__ vector unsigned long long __ATTRS_o_ai
1394 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1395  return __a & ~(vector unsigned long long)__b;
1396 }
1397 
1398 static __inline__ vector bool long long __ATTRS_o_ai
1399 vec_andc(vector bool long long __a, vector bool long long __b) {
1400  return __a & ~__b;
1401 }
1402 #endif
1403 
1404 /* vec_vandc */
1405 
1406 static __inline__ vector signed char __ATTRS_o_ai
1407 vec_vandc(vector signed char __a, vector signed char __b) {
1408  return __a & ~__b;
1409 }
1410 
1411 static __inline__ vector signed char __ATTRS_o_ai
1412 vec_vandc(vector bool char __a, vector signed char __b) {
1413  return (vector signed char)__a & ~__b;
1414 }
1415 
1416 static __inline__ vector signed char __ATTRS_o_ai
1417 vec_vandc(vector signed char __a, vector bool char __b) {
1418  return __a & ~(vector signed char)__b;
1419 }
1420 
1421 static __inline__ vector unsigned char __ATTRS_o_ai
1422 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1423  return __a & ~__b;
1424 }
1425 
1426 static __inline__ vector unsigned char __ATTRS_o_ai
1427 vec_vandc(vector bool char __a, vector unsigned char __b) {
1428  return (vector unsigned char)__a & ~__b;
1429 }
1430 
1431 static __inline__ vector unsigned char __ATTRS_o_ai
1432 vec_vandc(vector unsigned char __a, vector bool char __b) {
1433  return __a & ~(vector unsigned char)__b;
1434 }
1435 
1436 static __inline__ vector bool char __ATTRS_o_ai
1437 vec_vandc(vector bool char __a, vector bool char __b) {
1438  return __a & ~__b;
1439 }
1440 
1441 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1442  vector short __b) {
1443  return __a & ~__b;
1444 }
1445 
1446 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1447  vector short __b) {
1448  return (vector short)__a & ~__b;
1449 }
1450 
1451 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1452  vector bool short __b) {
1453  return __a & ~(vector short)__b;
1454 }
1455 
1456 static __inline__ vector unsigned short __ATTRS_o_ai
1457 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1458  return __a & ~__b;
1459 }
1460 
1461 static __inline__ vector unsigned short __ATTRS_o_ai
1462 vec_vandc(vector bool short __a, vector unsigned short __b) {
1463  return (vector unsigned short)__a & ~__b;
1464 }
1465 
1466 static __inline__ vector unsigned short __ATTRS_o_ai
1467 vec_vandc(vector unsigned short __a, vector bool short __b) {
1468  return __a & ~(vector unsigned short)__b;
1469 }
1470 
1471 static __inline__ vector bool short __ATTRS_o_ai
1472 vec_vandc(vector bool short __a, vector bool short __b) {
1473  return __a & ~__b;
1474 }
1475 
1476 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1477  vector int __b) {
1478  return __a & ~__b;
1479 }
1480 
1481 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1482  vector int __b) {
1483  return (vector int)__a & ~__b;
1484 }
1485 
1486 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1487  vector bool int __b) {
1488  return __a & ~(vector int)__b;
1489 }
1490 
1491 static __inline__ vector unsigned int __ATTRS_o_ai
1492 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1493  return __a & ~__b;
1494 }
1495 
1496 static __inline__ vector unsigned int __ATTRS_o_ai
1497 vec_vandc(vector bool int __a, vector unsigned int __b) {
1498  return (vector unsigned int)__a & ~__b;
1499 }
1500 
1501 static __inline__ vector unsigned int __ATTRS_o_ai
1502 vec_vandc(vector unsigned int __a, vector bool int __b) {
1503  return __a & ~(vector unsigned int)__b;
1504 }
1505 
1506 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1507  vector bool int __b) {
1508  return __a & ~__b;
1509 }
1510 
1511 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1512  vector float __b) {
1513  vector unsigned int __res =
1514  (vector unsigned int)__a & ~(vector unsigned int)__b;
1515  return (vector float)__res;
1516 }
1517 
1518 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1519  vector float __b) {
1520  vector unsigned int __res =
1521  (vector unsigned int)__a & ~(vector unsigned int)__b;
1522  return (vector float)__res;
1523 }
1524 
1525 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1526  vector bool int __b) {
1527  vector unsigned int __res =
1528  (vector unsigned int)__a & ~(vector unsigned int)__b;
1529  return (vector float)__res;
1530 }
1531 
1532 #ifdef __VSX__
1533 static __inline__ vector signed long long __ATTRS_o_ai
1534 vec_vandc(vector signed long long __a, vector signed long long __b) {
1535  return __a & ~__b;
1536 }
1537 
1538 static __inline__ vector signed long long __ATTRS_o_ai
1539 vec_vandc(vector bool long long __a, vector signed long long __b) {
1540  return (vector signed long long)__a & ~__b;
1541 }
1542 
1543 static __inline__ vector signed long long __ATTRS_o_ai
1544 vec_vandc(vector signed long long __a, vector bool long long __b) {
1545  return __a & ~(vector signed long long)__b;
1546 }
1547 
1548 static __inline__ vector unsigned long long __ATTRS_o_ai
1549 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1550  return __a & ~__b;
1551 }
1552 
1553 static __inline__ vector unsigned long long __ATTRS_o_ai
1554 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1555  return (vector unsigned long long)__a & ~__b;
1556 }
1557 
1558 static __inline__ vector unsigned long long __ATTRS_o_ai
1559 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1560  return __a & ~(vector unsigned long long)__b;
1561 }
1562 
1563 static __inline__ vector bool long long __ATTRS_o_ai
1564 vec_vandc(vector bool long long __a, vector bool long long __b) {
1565  return __a & ~__b;
1566 }
1567 #endif
1568 
1569 /* vec_avg */
1570 
1571 static __inline__ vector signed char __ATTRS_o_ai
1572 vec_avg(vector signed char __a, vector signed char __b) {
1573  return __builtin_altivec_vavgsb(__a, __b);
1574 }
1575 
1576 static __inline__ vector unsigned char __ATTRS_o_ai
1577 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1578  return __builtin_altivec_vavgub(__a, __b);
1579 }
1580 
1581 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1582  vector short __b) {
1583  return __builtin_altivec_vavgsh(__a, __b);
1584 }
1585 
1586 static __inline__ vector unsigned short __ATTRS_o_ai
1587 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1588  return __builtin_altivec_vavguh(__a, __b);
1589 }
1590 
1591 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1592  vector int __b) {
1593  return __builtin_altivec_vavgsw(__a, __b);
1594 }
1595 
1596 static __inline__ vector unsigned int __ATTRS_o_ai
1597 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1598  return __builtin_altivec_vavguw(__a, __b);
1599 }
1600 
1601 /* vec_vavgsb */
1602 
1603 static __inline__ vector signed char __attribute__((__always_inline__))
1604 vec_vavgsb(vector signed char __a, vector signed char __b) {
1605  return __builtin_altivec_vavgsb(__a, __b);
1606 }
1607 
1608 /* vec_vavgub */
1609 
1610 static __inline__ vector unsigned char __attribute__((__always_inline__))
1611 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1612  return __builtin_altivec_vavgub(__a, __b);
1613 }
1614 
1615 /* vec_vavgsh */
1616 
1617 static __inline__ vector short __attribute__((__always_inline__))
1618 vec_vavgsh(vector short __a, vector short __b) {
1619  return __builtin_altivec_vavgsh(__a, __b);
1620 }
1621 
1622 /* vec_vavguh */
1623 
1624 static __inline__ vector unsigned short __attribute__((__always_inline__))
1625 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1626  return __builtin_altivec_vavguh(__a, __b);
1627 }
1628 
1629 /* vec_vavgsw */
1630 
1631 static __inline__ vector int __attribute__((__always_inline__))
1632 vec_vavgsw(vector int __a, vector int __b) {
1633  return __builtin_altivec_vavgsw(__a, __b);
1634 }
1635 
1636 /* vec_vavguw */
1637 
1638 static __inline__ vector unsigned int __attribute__((__always_inline__))
1639 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1640  return __builtin_altivec_vavguw(__a, __b);
1641 }
1642 
1643 /* vec_ceil */
1644 
1645 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1646 #ifdef __VSX__
1647  return __builtin_vsx_xvrspip(__a);
1648 #else
1649  return __builtin_altivec_vrfip(__a);
1650 #endif
1651 }
1652 
1653 #ifdef __VSX__
1654 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1655  return __builtin_vsx_xvrdpip(__a);
1656 }
1657 #endif
1658 
1659 /* vec_roundp */
1660 static __inline__ vector float __ATTRS_o_ai vec_roundp(vector float __a) {
1661  return vec_ceil(__a);
1662 }
1663 
1664 #ifdef __VSX__
1665 static __inline__ vector double __ATTRS_o_ai vec_roundp(vector double __a) {
1666  return vec_ceil(__a);
1667 }
1668 #endif
1669 
1670 /* vec_vrfip */
1671 
1672 static __inline__ vector float __attribute__((__always_inline__))
1673 vec_vrfip(vector float __a) {
1674  return __builtin_altivec_vrfip(__a);
1675 }
1676 
1677 /* vec_cmpb */
1678 
1679 static __inline__ vector int __attribute__((__always_inline__))
1680 vec_cmpb(vector float __a, vector float __b) {
1681  return __builtin_altivec_vcmpbfp(__a, __b);
1682 }
1683 
1684 /* vec_vcmpbfp */
1685 
1686 static __inline__ vector int __attribute__((__always_inline__))
1687 vec_vcmpbfp(vector float __a, vector float __b) {
1688  return __builtin_altivec_vcmpbfp(__a, __b);
1689 }
1690 
1691 /* vec_cmpeq */
1692 
1693 static __inline__ vector bool char __ATTRS_o_ai
1694 vec_cmpeq(vector signed char __a, vector signed char __b) {
1695  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1696  (vector char)__b);
1697 }
1698 
1699 static __inline__ vector bool char __ATTRS_o_ai
1700 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1701  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1702  (vector char)__b);
1703 }
1704 
1705 static __inline__ vector bool char __ATTRS_o_ai
1706 vec_cmpeq(vector bool char __a, vector bool char __b) {
1707  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1708  (vector char)__b);
1709 }
1710 
1711 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1712  vector short __b) {
1713  return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1714 }
1715 
1716 static __inline__ vector bool short __ATTRS_o_ai
1717 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1718  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1719  (vector short)__b);
1720 }
1721 
1722 static __inline__ vector bool short __ATTRS_o_ai
1723 vec_cmpeq(vector bool short __a, vector bool short __b) {
1724  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1725  (vector short)__b);
1726 }
1727 
1728 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1729  vector int __b) {
1730  return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1731 }
1732 
1733 static __inline__ vector bool int __ATTRS_o_ai
1734 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1735  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1736  (vector int)__b);
1737 }
1738 
1739 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector bool int __a,
1740  vector bool int __b) {
1741  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1742  (vector int)__b);
1743 }
1744 
1745 #ifdef __POWER8_VECTOR__
1746 static __inline__ vector bool long long __ATTRS_o_ai
1747 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1748  return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1749 }
1750 
1751 static __inline__ vector bool long long __ATTRS_o_ai
1752 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1753  return (vector bool long long)__builtin_altivec_vcmpequd(
1754  (vector long long)__a, (vector long long)__b);
1755 }
1756 
1757 static __inline__ vector bool long long __ATTRS_o_ai
1758 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1759  return (vector bool long long)__builtin_altivec_vcmpequd(
1760  (vector long long)__a, (vector long long)__b);
1761 }
1762 #elif defined(__VSX__)
1763 static __inline__ vector bool long long __ATTRS_o_ai
1764 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1765  vector bool int __wordcmp =
1766  vec_cmpeq((vector signed int)__a, (vector signed int)__b);
1767 #ifdef __LITTLE_ENDIAN__
1768  __wordcmp &= __builtin_shufflevector(__wordcmp, __wordcmp, 3, 0, 1, 2);
1769  return (vector bool long long)__builtin_shufflevector(__wordcmp, __wordcmp, 1,
1770  1, 3, 3);
1771 #else
1772  __wordcmp &= __builtin_shufflevector(__wordcmp, __wordcmp, 1, 2, 3, 0);
1773  return (vector bool long long)__builtin_shufflevector(__wordcmp, __wordcmp, 0,
1774  0, 2, 2);
1775 #endif
1776 }
1777 
1778 static __inline__ vector bool long long __ATTRS_o_ai
1779 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1780  return vec_cmpeq((vector signed long long)__a, (vector signed long long)__b);
1781 }
1782 
1783 static __inline__ vector bool long long __ATTRS_o_ai
1784 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1785  return vec_cmpeq((vector signed long long)__a, (vector signed long long)__b);
1786 }
1787 #endif
1788 
1789 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1790  vector float __b) {
1791 #ifdef __VSX__
1792  return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1793 #else
1794  return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1795 #endif
1796 }
1797 
1798 #ifdef __VSX__
1799 static __inline__ vector bool long long __ATTRS_o_ai
1800 vec_cmpeq(vector double __a, vector double __b) {
1801  return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1802 }
1803 #endif
1804 
1805 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
1806 static __inline__ vector bool __int128 __ATTRS_o_ai
1807 vec_cmpeq(vector signed __int128 __a, vector signed __int128 __b) {
1808  return (vector bool __int128)__builtin_altivec_vcmpequq(
1809  (vector bool __int128)__a, (vector bool __int128)__b);
1810 }
1811 
1812 static __inline__ vector bool __int128 __ATTRS_o_ai
1813 vec_cmpeq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
1814  return (vector bool __int128)__builtin_altivec_vcmpequq(
1815  (vector bool __int128)__a, (vector bool __int128)__b);
1816 }
1817 
1818 static __inline__ vector bool __int128 __ATTRS_o_ai
1819 vec_cmpeq(vector bool __int128 __a, vector bool __int128 __b) {
1820  return (vector bool __int128)__builtin_altivec_vcmpequq(__a, __b);
1821 }
1822 #endif
1823 
1824 #ifdef __POWER9_VECTOR__
1825 /* vec_cmpne */
1826 
1827 static __inline__ vector bool char __ATTRS_o_ai
1828 vec_cmpne(vector bool char __a, vector bool char __b) {
1829  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1830  (vector char)__b);
1831 }
1832 
1833 static __inline__ vector bool char __ATTRS_o_ai
1834 vec_cmpne(vector signed char __a, vector signed char __b) {
1835  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1836  (vector char)__b);
1837 }
1838 
1839 static __inline__ vector bool char __ATTRS_o_ai
1840 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
1841  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1842  (vector char)__b);
1843 }
1844 
1845 static __inline__ vector bool short __ATTRS_o_ai
1846 vec_cmpne(vector bool short __a, vector bool short __b) {
1847  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1848  (vector short)__b);
1849 }
1850 
1851 static __inline__ vector bool short __ATTRS_o_ai
1852 vec_cmpne(vector signed short __a, vector signed short __b) {
1853  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1854  (vector short)__b);
1855 }
1856 
1857 static __inline__ vector bool short __ATTRS_o_ai
1858 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
1859  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1860  (vector short)__b);
1861 }
1862 
1863 static __inline__ vector bool int __ATTRS_o_ai
1864 vec_cmpne(vector bool int __a, vector bool int __b) {
1865  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1866  (vector int)__b);
1867 }
1868 
1869 static __inline__ vector bool int __ATTRS_o_ai
1870 vec_cmpne(vector signed int __a, vector signed int __b) {
1871  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1872  (vector int)__b);
1873 }
1874 
1875 static __inline__ vector bool int __ATTRS_o_ai
1876 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
1877  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1878  (vector int)__b);
1879 }
1880 
1881 static __inline__ vector bool int __ATTRS_o_ai
1882 vec_cmpne(vector float __a, vector float __b) {
1883  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1884  (vector int)__b);
1885 }
1886 
1887 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
1888 static __inline__ vector bool __int128 __ATTRS_o_ai
1889 vec_cmpne(vector unsigned __int128 __a, vector unsigned __int128 __b) {
1890  return (vector bool __int128) ~(__builtin_altivec_vcmpequq(
1891  (vector bool __int128)__a, (vector bool __int128)__b));
1892 }
1893 
1894 static __inline__ vector bool __int128 __ATTRS_o_ai
1895 vec_cmpne(vector signed __int128 __a, vector signed __int128 __b) {
1896  return (vector bool __int128) ~(__builtin_altivec_vcmpequq(
1897  (vector bool __int128)__a, (vector bool __int128)__b));
1898 }
1899 
1900 static __inline__ vector bool __int128 __ATTRS_o_ai
1901 vec_cmpne(vector bool __int128 __a, vector bool __int128 __b) {
1902  return (vector bool __int128) ~(__builtin_altivec_vcmpequq(__a, __b));
1903 }
1904 #endif
1905 
1906 /* vec_cmpnez */
1907 
1908 static __inline__ vector bool char __ATTRS_o_ai
1909 vec_cmpnez(vector signed char __a, vector signed char __b) {
1910  return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1911  (vector char)__b);
1912 }
1913 
1914 static __inline__ vector bool char __ATTRS_o_ai
1915 vec_cmpnez(vector unsigned char __a, vector unsigned char __b) {
1916  return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1917  (vector char)__b);
1918 }
1919 
1920 static __inline__ vector bool short __ATTRS_o_ai
1921 vec_cmpnez(vector signed short __a, vector signed short __b) {
1922  return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1923  (vector short)__b);
1924 }
1925 
1926 static __inline__ vector bool short __ATTRS_o_ai
1927 vec_cmpnez(vector unsigned short __a, vector unsigned short __b) {
1928  return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1929  (vector short)__b);
1930 }
1931 
1932 static __inline__ vector bool int __ATTRS_o_ai
1933 vec_cmpnez(vector signed int __a, vector signed int __b) {
1934  return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1935  (vector int)__b);
1936 }
1937 
1938 static __inline__ vector bool int __ATTRS_o_ai
1939 vec_cmpnez(vector unsigned int __a, vector unsigned int __b) {
1940  return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1941  (vector int)__b);
1942 }
1943 
1944 static __inline__ signed int __ATTRS_o_ai
1945 vec_cntlz_lsbb(vector signed char __a) {
1946 #ifdef __LITTLE_ENDIAN__
1947  return __builtin_altivec_vctzlsbb(__a);
1948 #else
1949  return __builtin_altivec_vclzlsbb(__a);
1950 #endif
1951 }
1952 
1953 static __inline__ signed int __ATTRS_o_ai
1954 vec_cntlz_lsbb(vector unsigned char __a) {
1955 #ifdef __LITTLE_ENDIAN__
1956  return __builtin_altivec_vctzlsbb(__a);
1957 #else
1958  return __builtin_altivec_vclzlsbb(__a);
1959 #endif
1960 }
1961 
1962 static __inline__ signed int __ATTRS_o_ai
1963 vec_cnttz_lsbb(vector signed char __a) {
1964 #ifdef __LITTLE_ENDIAN__
1965  return __builtin_altivec_vclzlsbb(__a);
1966 #else
1967  return __builtin_altivec_vctzlsbb(__a);
1968 #endif
1969 }
1970 
1971 static __inline__ signed int __ATTRS_o_ai
1972 vec_cnttz_lsbb(vector unsigned char __a) {
1973 #ifdef __LITTLE_ENDIAN__
1974  return __builtin_altivec_vclzlsbb(__a);
1975 #else
1976  return __builtin_altivec_vctzlsbb(__a);
1977 #endif
1978 }
1979 
1980 static __inline__ vector unsigned int __ATTRS_o_ai
1981 vec_parity_lsbb(vector unsigned int __a) {
1982  return __builtin_altivec_vprtybw(__a);
1983 }
1984 
1985 static __inline__ vector unsigned int __ATTRS_o_ai
1986 vec_parity_lsbb(vector signed int __a) {
1987  return __builtin_altivec_vprtybw(__a);
1988 }
1989 
1990 #ifdef __SIZEOF_INT128__
1991 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1992 vec_parity_lsbb(vector unsigned __int128 __a) {
1993  return __builtin_altivec_vprtybq(__a);
1994 }
1995 
1996 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1997 vec_parity_lsbb(vector signed __int128 __a) {
1998  return __builtin_altivec_vprtybq(__a);
1999 }
2000 #endif
2001 
2002 static __inline__ vector unsigned long long __ATTRS_o_ai
2003 vec_parity_lsbb(vector unsigned long long __a) {
2004  return __builtin_altivec_vprtybd(__a);
2005 }
2006 
2007 static __inline__ vector unsigned long long __ATTRS_o_ai
2008 vec_parity_lsbb(vector signed long long __a) {
2009  return __builtin_altivec_vprtybd(__a);
2010 }
2011 
2012 #else
2013 /* vec_cmpne */
2014 
2015 static __inline__ vector bool char __ATTRS_o_ai
2016 vec_cmpne(vector bool char __a, vector bool char __b) {
2017  return ~(vec_cmpeq(__a, __b));
2018 }
2019 
2020 static __inline__ vector bool char __ATTRS_o_ai
2021 vec_cmpne(vector signed char __a, vector signed char __b) {
2022  return ~(vec_cmpeq(__a, __b));
2023 }
2024 
2025 static __inline__ vector bool char __ATTRS_o_ai
2026 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
2027  return ~(vec_cmpeq(__a, __b));
2028 }
2029 
2030 static __inline__ vector bool short __ATTRS_o_ai
2031 vec_cmpne(vector bool short __a, vector bool short __b) {
2032  return ~(vec_cmpeq(__a, __b));
2033 }
2034 
2035 static __inline__ vector bool short __ATTRS_o_ai
2036 vec_cmpne(vector signed short __a, vector signed short __b) {
2037  return ~(vec_cmpeq(__a, __b));
2038 }
2039 
2040 static __inline__ vector bool short __ATTRS_o_ai
2041 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
2042  return ~(vec_cmpeq(__a, __b));
2043 }
2044 
2045 static __inline__ vector bool int __ATTRS_o_ai
2046 vec_cmpne(vector bool int __a, vector bool int __b) {
2047  return ~(vec_cmpeq(__a, __b));
2048 }
2049 
2050 static __inline__ vector bool int __ATTRS_o_ai
2051 vec_cmpne(vector signed int __a, vector signed int __b) {
2052  return ~(vec_cmpeq(__a, __b));
2053 }
2054 
2055 static __inline__ vector bool int __ATTRS_o_ai
2056 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
2057  return ~(vec_cmpeq(__a, __b));
2058 }
2059 
2060 static __inline__ vector bool int __ATTRS_o_ai
2061 vec_cmpne(vector float __a, vector float __b) {
2062  return ~(vec_cmpeq(__a, __b));
2063 }
2064 #endif
2065 
2066 #ifdef __POWER8_VECTOR__
2067 static __inline__ vector bool long long __ATTRS_o_ai
2068 vec_cmpne(vector bool long long __a, vector bool long long __b) {
2069  return (vector bool long long)
2070  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2071 }
2072 
2073 static __inline__ vector bool long long __ATTRS_o_ai
2074 vec_cmpne(vector signed long long __a, vector signed long long __b) {
2075  return (vector bool long long)
2076  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2077 }
2078 
2079 static __inline__ vector bool long long __ATTRS_o_ai
2080 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
2081  return (vector bool long long)
2082  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2083 }
2084 #elif defined(__VSX__)
2085 static __inline__ vector bool long long __ATTRS_o_ai
2086 vec_cmpne(vector bool long long __a, vector bool long long __b) {
2087  return (vector bool long long)~(
2088  vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2089 }
2090 
2091 static __inline__ vector bool long long __ATTRS_o_ai
2092 vec_cmpne(vector signed long long __a, vector signed long long __b) {
2093  return (vector bool long long)~(
2094  vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2095 }
2096 
2097 static __inline__ vector bool long long __ATTRS_o_ai
2098 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
2099  return (vector bool long long)~(
2100  vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2101 }
2102 #endif
2103 
2104 #ifdef __VSX__
2105 static __inline__ vector bool long long __ATTRS_o_ai
2106 vec_cmpne(vector double __a, vector double __b) {
2107  return (vector bool long long)
2108  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2109 }
2110 #endif
2111 
2112 /* vec_cmpgt */
2113 
2114 static __inline__ vector bool char __ATTRS_o_ai
2115 vec_cmpgt(vector signed char __a, vector signed char __b) {
2116  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2117 }
2118 
2119 static __inline__ vector bool char __ATTRS_o_ai
2120 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
2121  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2122 }
2123 
2124 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
2125  vector short __b) {
2126  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2127 }
2128 
2129 static __inline__ vector bool short __ATTRS_o_ai
2130 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
2131  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2132 }
2133 
2134 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
2135  vector int __b) {
2136  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2137 }
2138 
2139 static __inline__ vector bool int __ATTRS_o_ai
2140 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
2141  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2142 }
2143 
2144 #ifdef __POWER8_VECTOR__
2145 static __inline__ vector bool long long __ATTRS_o_ai
2146 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
2147  return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
2148 }
2149 
2150 static __inline__ vector bool long long __ATTRS_o_ai
2151 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
2152  return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
2153 }
2154 #elif defined(__VSX__)
2155 static __inline__ vector bool long long __ATTRS_o_ai
2156 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
2157  vector signed int __sgtw = (vector signed int)vec_cmpgt(
2158  (vector signed int)__a, (vector signed int)__b);
2159  vector unsigned int __ugtw = (vector unsigned int)vec_cmpgt(
2160  (vector unsigned int)__a, (vector unsigned int)__b);
2161  vector unsigned int __eqw = (vector unsigned int)vec_cmpeq(
2162  (vector signed int)__a, (vector signed int)__b);
2163 #ifdef __LITTLE_ENDIAN__
2164  __ugtw = __builtin_shufflevector(__ugtw, __ugtw, 3, 0, 1, 2) & __eqw;
2165  __sgtw |= (vector signed int)__ugtw;
2166  return (vector bool long long)__builtin_shufflevector(__sgtw, __sgtw, 1, 1, 3,
2167  3);
2168 #else
2169  __ugtw = __builtin_shufflevector(__ugtw, __ugtw, 1, 2, 3, 0) & __eqw;
2170  __sgtw |= (vector signed int)__ugtw;
2171  return (vector bool long long)__builtin_shufflevector(__sgtw, __sgtw, 0, 0, 2,
2172  2);
2173 #endif
2174 }
2175 
2176 static __inline__ vector bool long long __ATTRS_o_ai
2177 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
2178  vector unsigned int __ugtw = (vector unsigned int)vec_cmpgt(
2179  (vector unsigned int)__a, (vector unsigned int)__b);
2180  vector unsigned int __eqw = (vector unsigned int)vec_cmpeq(
2181  (vector signed int)__a, (vector signed int)__b);
2182 #ifdef __LITTLE_ENDIAN__
2183  __eqw = __builtin_shufflevector(__ugtw, __ugtw, 3, 0, 1, 2) & __eqw;
2184  __ugtw |= __eqw;
2185  return (vector bool long long)__builtin_shufflevector(__ugtw, __ugtw, 1, 1, 3,
2186  3);
2187 #else
2188  __eqw = __builtin_shufflevector(__ugtw, __ugtw, 1, 2, 3, 0) & __eqw;
2189  __ugtw |= __eqw;
2190  return (vector bool long long)__builtin_shufflevector(__ugtw, __ugtw, 0, 0, 2,
2191  2);
2192 #endif
2193 }
2194 #endif
2195 
2196 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
2197  vector float __b) {
2198 #ifdef __VSX__
2199  return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
2200 #else
2201  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2202 #endif
2203 }
2204 
2205 #ifdef __VSX__
2206 static __inline__ vector bool long long __ATTRS_o_ai
2207 vec_cmpgt(vector double __a, vector double __b) {
2208  return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
2209 }
2210 #endif
2211 
2212 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2213 static __inline__ vector bool __int128 __ATTRS_o_ai
2214 vec_cmpgt(vector signed __int128 __a, vector signed __int128 __b) {
2215  return (vector bool __int128)__builtin_altivec_vcmpgtsq(
2216  (vector bool __int128)__a, (vector bool __int128)__b);
2217 }
2218 
2219 static __inline__ vector bool __int128 __ATTRS_o_ai
2220 vec_cmpgt(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2221  return (vector bool __int128)__builtin_altivec_vcmpgtuq(
2222  (vector bool __int128)__a, (vector bool __int128)__b);
2223 }
2224 #endif
2225 
2226 /* vec_cmpge */
2227 
2228 static __inline__ vector bool char __ATTRS_o_ai
2229 vec_cmpge(vector signed char __a, vector signed char __b) {
2230  return ~(vec_cmpgt(__b, __a));
2231 }
2232 
2233 static __inline__ vector bool char __ATTRS_o_ai
2234 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
2235  return ~(vec_cmpgt(__b, __a));
2236 }
2237 
2238 static __inline__ vector bool short __ATTRS_o_ai
2239 vec_cmpge(vector signed short __a, vector signed short __b) {
2240  return ~(vec_cmpgt(__b, __a));
2241 }
2242 
2243 static __inline__ vector bool short __ATTRS_o_ai
2244 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
2245  return ~(vec_cmpgt(__b, __a));
2246 }
2247 
2248 static __inline__ vector bool int __ATTRS_o_ai
2249 vec_cmpge(vector signed int __a, vector signed int __b) {
2250  return ~(vec_cmpgt(__b, __a));
2251 }
2252 
2253 static __inline__ vector bool int __ATTRS_o_ai
2254 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
2255  return ~(vec_cmpgt(__b, __a));
2256 }
2257 
2258 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
2259  vector float __b) {
2260 #ifdef __VSX__
2261  return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
2262 #else
2263  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2264 #endif
2265 }
2266 
2267 #ifdef __VSX__
2268 static __inline__ vector bool long long __ATTRS_o_ai
2269 vec_cmpge(vector double __a, vector double __b) {
2270  return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
2271 }
2272 
2273 static __inline__ vector bool long long __ATTRS_o_ai
2274 vec_cmpge(vector signed long long __a, vector signed long long __b) {
2275  return ~(vec_cmpgt(__b, __a));
2276 }
2277 
2278 static __inline__ vector bool long long __ATTRS_o_ai
2279 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
2280  return ~(vec_cmpgt(__b, __a));
2281 }
2282 #endif
2283 
2284 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2285 static __inline__ vector bool __int128 __ATTRS_o_ai
2286 vec_cmpge(vector signed __int128 __a, vector signed __int128 __b) {
2287  return ~(vec_cmpgt(__b, __a));
2288 }
2289 
2290 static __inline__ vector bool __int128 __ATTRS_o_ai
2291 vec_cmpge(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2292  return ~(vec_cmpgt(__b, __a));
2293 }
2294 #endif
2295 
2296 /* vec_vcmpgefp */
2297 
2298 static __inline__ vector bool int __attribute__((__always_inline__))
2299 vec_vcmpgefp(vector float __a, vector float __b) {
2300  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2301 }
2302 
2303 /* vec_vcmpgtsb */
2304 
2305 static __inline__ vector bool char __attribute__((__always_inline__))
2306 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
2307  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2308 }
2309 
2310 /* vec_vcmpgtub */
2311 
2312 static __inline__ vector bool char __attribute__((__always_inline__))
2313 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
2314  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2315 }
2316 
2317 /* vec_vcmpgtsh */
2318 
2319 static __inline__ vector bool short __attribute__((__always_inline__))
2320 vec_vcmpgtsh(vector short __a, vector short __b) {
2321  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2322 }
2323 
2324 /* vec_vcmpgtuh */
2325 
2326 static __inline__ vector bool short __attribute__((__always_inline__))
2327 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
2328  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2329 }
2330 
2331 /* vec_vcmpgtsw */
2332 
2333 static __inline__ vector bool int __attribute__((__always_inline__))
2334 vec_vcmpgtsw(vector int __a, vector int __b) {
2335  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2336 }
2337 
2338 /* vec_vcmpgtuw */
2339 
2340 static __inline__ vector bool int __attribute__((__always_inline__))
2341 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
2342  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2343 }
2344 
2345 /* vec_vcmpgtfp */
2346 
2347 static __inline__ vector bool int __attribute__((__always_inline__))
2348 vec_vcmpgtfp(vector float __a, vector float __b) {
2349  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2350 }
2351 
2352 /* vec_cmple */
2353 
2354 static __inline__ vector bool char __ATTRS_o_ai
2355 vec_cmple(vector signed char __a, vector signed char __b) {
2356  return vec_cmpge(__b, __a);
2357 }
2358 
2359 static __inline__ vector bool char __ATTRS_o_ai
2360 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
2361  return vec_cmpge(__b, __a);
2362 }
2363 
2364 static __inline__ vector bool short __ATTRS_o_ai
2365 vec_cmple(vector signed short __a, vector signed short __b) {
2366  return vec_cmpge(__b, __a);
2367 }
2368 
2369 static __inline__ vector bool short __ATTRS_o_ai
2370 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
2371  return vec_cmpge(__b, __a);
2372 }
2373 
2374 static __inline__ vector bool int __ATTRS_o_ai
2375 vec_cmple(vector signed int __a, vector signed int __b) {
2376  return vec_cmpge(__b, __a);
2377 }
2378 
2379 static __inline__ vector bool int __ATTRS_o_ai
2380 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
2381  return vec_cmpge(__b, __a);
2382 }
2383 
2384 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
2385  vector float __b) {
2386  return vec_cmpge(__b, __a);
2387 }
2388 
2389 #ifdef __VSX__
2390 static __inline__ vector bool long long __ATTRS_o_ai
2391 vec_cmple(vector double __a, vector double __b) {
2392  return vec_cmpge(__b, __a);
2393 }
2394 
2395 static __inline__ vector bool long long __ATTRS_o_ai
2396 vec_cmple(vector signed long long __a, vector signed long long __b) {
2397  return vec_cmpge(__b, __a);
2398 }
2399 
2400 static __inline__ vector bool long long __ATTRS_o_ai
2401 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
2402  return vec_cmpge(__b, __a);
2403 }
2404 #endif
2405 
2406 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2407 static __inline__ vector bool __int128 __ATTRS_o_ai
2408 vec_cmple(vector signed __int128 __a, vector signed __int128 __b) {
2409  return vec_cmpge(__b, __a);
2410 }
2411 
2412 static __inline__ vector bool __int128 __ATTRS_o_ai
2413 vec_cmple(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2414  return vec_cmpge(__b, __a);
2415 }
2416 #endif
2417 
2418 /* vec_cmplt */
2419 
2420 static __inline__ vector bool char __ATTRS_o_ai
2421 vec_cmplt(vector signed char __a, vector signed char __b) {
2422  return vec_cmpgt(__b, __a);
2423 }
2424 
2425 static __inline__ vector bool char __ATTRS_o_ai
2426 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
2427  return vec_cmpgt(__b, __a);
2428 }
2429 
2430 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
2431  vector short __b) {
2432  return vec_cmpgt(__b, __a);
2433 }
2434 
2435 static __inline__ vector bool short __ATTRS_o_ai
2436 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
2437  return vec_cmpgt(__b, __a);
2438 }
2439 
2440 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
2441  vector int __b) {
2442  return vec_cmpgt(__b, __a);
2443 }
2444 
2445 static __inline__ vector bool int __ATTRS_o_ai
2446 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
2447  return vec_cmpgt(__b, __a);
2448 }
2449 
2450 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
2451  vector float __b) {
2452  return vec_cmpgt(__b, __a);
2453 }
2454 
2455 #ifdef __VSX__
2456 static __inline__ vector bool long long __ATTRS_o_ai
2457 vec_cmplt(vector double __a, vector double __b) {
2458  return vec_cmpgt(__b, __a);
2459 }
2460 #endif
2461 
2462 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2463 static __inline__ vector bool __int128 __ATTRS_o_ai
2464 vec_cmplt(vector signed __int128 __a, vector signed __int128 __b) {
2465  return vec_cmpgt(__b, __a);
2466 }
2467 
2468 static __inline__ vector bool __int128 __ATTRS_o_ai
2469 vec_cmplt(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2470  return vec_cmpgt(__b, __a);
2471 }
2472 #endif
2473 
2474 #ifdef __VSX__
2475 static __inline__ vector bool long long __ATTRS_o_ai
2476 vec_cmplt(vector signed long long __a, vector signed long long __b) {
2477  return vec_cmpgt(__b, __a);
2478 }
2479 
2480 static __inline__ vector bool long long __ATTRS_o_ai
2481 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
2482  return vec_cmpgt(__b, __a);
2483 }
2484 #endif
2485 
2486 #ifdef __POWER8_VECTOR__
2487 /* vec_popcnt */
2488 
2489 static __inline__ vector unsigned char __ATTRS_o_ai
2490 vec_popcnt(vector signed char __a) {
2491  return __builtin_altivec_vpopcntb(__a);
2492 }
2493 static __inline__ vector unsigned char __ATTRS_o_ai
2494 vec_popcnt(vector unsigned char __a) {
2495  return __builtin_altivec_vpopcntb(__a);
2496 }
2497 static __inline__ vector unsigned short __ATTRS_o_ai
2498 vec_popcnt(vector signed short __a) {
2499  return __builtin_altivec_vpopcnth(__a);
2500 }
2501 static __inline__ vector unsigned short __ATTRS_o_ai
2502 vec_popcnt(vector unsigned short __a) {
2503  return __builtin_altivec_vpopcnth(__a);
2504 }
2505 static __inline__ vector unsigned int __ATTRS_o_ai
2506 vec_popcnt(vector signed int __a) {
2507  return __builtin_altivec_vpopcntw(__a);
2508 }
2509 static __inline__ vector unsigned int __ATTRS_o_ai
2510 vec_popcnt(vector unsigned int __a) {
2511  return __builtin_altivec_vpopcntw(__a);
2512 }
2513 static __inline__ vector unsigned long long __ATTRS_o_ai
2514 vec_popcnt(vector signed long long __a) {
2515  return __builtin_altivec_vpopcntd(__a);
2516 }
2517 static __inline__ vector unsigned long long __ATTRS_o_ai
2518 vec_popcnt(vector unsigned long long __a) {
2519  return __builtin_altivec_vpopcntd(__a);
2520 }
2521 
2522 #define vec_vclz vec_cntlz
2523 /* vec_cntlz */
2524 
2525 static __inline__ vector signed char __ATTRS_o_ai
2526 vec_cntlz(vector signed char __a) {
2527  return __builtin_altivec_vclzb(__a);
2528 }
2529 static __inline__ vector unsigned char __ATTRS_o_ai
2530 vec_cntlz(vector unsigned char __a) {
2531  return __builtin_altivec_vclzb(__a);
2532 }
2533 static __inline__ vector signed short __ATTRS_o_ai
2534 vec_cntlz(vector signed short __a) {
2535  return __builtin_altivec_vclzh(__a);
2536 }
2537 static __inline__ vector unsigned short __ATTRS_o_ai
2538 vec_cntlz(vector unsigned short __a) {
2539  return __builtin_altivec_vclzh(__a);
2540 }
2541 static __inline__ vector signed int __ATTRS_o_ai
2542 vec_cntlz(vector signed int __a) {
2543  return __builtin_altivec_vclzw(__a);
2544 }
2545 static __inline__ vector unsigned int __ATTRS_o_ai
2546 vec_cntlz(vector unsigned int __a) {
2547  return __builtin_altivec_vclzw(__a);
2548 }
2549 static __inline__ vector signed long long __ATTRS_o_ai
2550 vec_cntlz(vector signed long long __a) {
2551  return __builtin_altivec_vclzd(__a);
2552 }
2553 static __inline__ vector unsigned long long __ATTRS_o_ai
2554 vec_cntlz(vector unsigned long long __a) {
2555  return __builtin_altivec_vclzd(__a);
2556 }
2557 #endif
2558 
2559 #ifdef __POWER9_VECTOR__
2560 
2561 /* vec_cnttz */
2562 
2563 static __inline__ vector signed char __ATTRS_o_ai
2564 vec_cnttz(vector signed char __a) {
2565  return __builtin_altivec_vctzb(__a);
2566 }
2567 static __inline__ vector unsigned char __ATTRS_o_ai
2568 vec_cnttz(vector unsigned char __a) {
2569  return __builtin_altivec_vctzb(__a);
2570 }
2571 static __inline__ vector signed short __ATTRS_o_ai
2572 vec_cnttz(vector signed short __a) {
2573  return __builtin_altivec_vctzh(__a);
2574 }
2575 static __inline__ vector unsigned short __ATTRS_o_ai
2576 vec_cnttz(vector unsigned short __a) {
2577  return __builtin_altivec_vctzh(__a);
2578 }
2579 static __inline__ vector signed int __ATTRS_o_ai
2580 vec_cnttz(vector signed int __a) {
2581  return __builtin_altivec_vctzw(__a);
2582 }
2583 static __inline__ vector unsigned int __ATTRS_o_ai
2584 vec_cnttz(vector unsigned int __a) {
2585  return __builtin_altivec_vctzw(__a);
2586 }
2587 static __inline__ vector signed long long __ATTRS_o_ai
2588 vec_cnttz(vector signed long long __a) {
2589  return __builtin_altivec_vctzd(__a);
2590 }
2591 static __inline__ vector unsigned long long __ATTRS_o_ai
2592 vec_cnttz(vector unsigned long long __a) {
2593  return __builtin_altivec_vctzd(__a);
2594 }
2595 
2596 /* vec_first_match_index */
2597 
2598 static __inline__ unsigned __ATTRS_o_ai
2599 vec_first_match_index(vector signed char __a, vector signed char __b) {
2600  vector unsigned long long __res =
2601 #ifdef __LITTLE_ENDIAN__
2602  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2603 #else
2604  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2605 #endif
2606  if (__res[0] == 64) {
2607  return (__res[1] + 64) >> 3;
2608  }
2609  return __res[0] >> 3;
2610 }
2611 
2612 static __inline__ unsigned __ATTRS_o_ai
2613 vec_first_match_index(vector unsigned char __a, vector unsigned char __b) {
2614  vector unsigned long long __res =
2615 #ifdef __LITTLE_ENDIAN__
2616  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2617 #else
2618  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2619 #endif
2620  if (__res[0] == 64) {
2621  return (__res[1] + 64) >> 3;
2622  }
2623  return __res[0] >> 3;
2624 }
2625 
2626 static __inline__ unsigned __ATTRS_o_ai
2627 vec_first_match_index(vector signed short __a, vector signed short __b) {
2628  vector unsigned long long __res =
2629 #ifdef __LITTLE_ENDIAN__
2630  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2631 #else
2632  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2633 #endif
2634  if (__res[0] == 64) {
2635  return (__res[1] + 64) >> 4;
2636  }
2637  return __res[0] >> 4;
2638 }
2639 
2640 static __inline__ unsigned __ATTRS_o_ai
2641 vec_first_match_index(vector unsigned short __a, vector unsigned short __b) {
2642  vector unsigned long long __res =
2643 #ifdef __LITTLE_ENDIAN__
2644  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2645 #else
2646  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2647 #endif
2648  if (__res[0] == 64) {
2649  return (__res[1] + 64) >> 4;
2650  }
2651  return __res[0] >> 4;
2652 }
2653 
2654 static __inline__ unsigned __ATTRS_o_ai
2655 vec_first_match_index(vector signed int __a, vector signed int __b) {
2656  vector unsigned long long __res =
2657 #ifdef __LITTLE_ENDIAN__
2658  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2659 #else
2660  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2661 #endif
2662  if (__res[0] == 64) {
2663  return (__res[1] + 64) >> 5;
2664  }
2665  return __res[0] >> 5;
2666 }
2667 
2668 static __inline__ unsigned __ATTRS_o_ai
2669 vec_first_match_index(vector unsigned int __a, vector unsigned int __b) {
2670  vector unsigned long long __res =
2671 #ifdef __LITTLE_ENDIAN__
2672  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2673 #else
2674  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2675 #endif
2676  if (__res[0] == 64) {
2677  return (__res[1] + 64) >> 5;
2678  }
2679  return __res[0] >> 5;
2680 }
2681 
2682 /* vec_first_match_or_eos_index */
2683 
2684 static __inline__ unsigned __ATTRS_o_ai
2685 vec_first_match_or_eos_index(vector signed char __a, vector signed char __b) {
2686  /* Compare the result of the comparison of two vectors with either and OR the
2687  result. Either the elements are equal or one will equal the comparison
2688  result if either is zero.
2689  */
2690  vector bool char __tmp1 = vec_cmpeq(__a, __b);
2691  vector bool char __tmp2 = __tmp1 |
2692  vec_cmpeq((vector signed char)__tmp1, __a) |
2693  vec_cmpeq((vector signed char)__tmp1, __b);
2694 
2695  vector unsigned long long __res =
2696 #ifdef __LITTLE_ENDIAN__
2697  vec_cnttz((vector unsigned long long)__tmp2);
2698 #else
2699  vec_cntlz((vector unsigned long long)__tmp2);
2700 #endif
2701  if (__res[0] == 64) {
2702  return (__res[1] + 64) >> 3;
2703  }
2704  return __res[0] >> 3;
2705 }
2706 
2707 static __inline__ unsigned __ATTRS_o_ai
2708 vec_first_match_or_eos_index(vector unsigned char __a,
2709  vector unsigned char __b) {
2710  vector bool char __tmp1 = vec_cmpeq(__a, __b);
2711  vector bool char __tmp2 = __tmp1 |
2712  vec_cmpeq((vector unsigned char)__tmp1, __a) |
2713  vec_cmpeq((vector unsigned char)__tmp1, __b);
2714 
2715  vector unsigned long long __res =
2716 #ifdef __LITTLE_ENDIAN__
2717  vec_cnttz((vector unsigned long long)__tmp2);
2718 #else
2719  vec_cntlz((vector unsigned long long)__tmp2);
2720 #endif
2721  if (__res[0] == 64) {
2722  return (__res[1] + 64) >> 3;
2723  }
2724  return __res[0] >> 3;
2725 }
2726 
2727 static __inline__ unsigned __ATTRS_o_ai
2728 vec_first_match_or_eos_index(vector signed short __a, vector signed short __b) {
2729  vector bool short __tmp1 = vec_cmpeq(__a, __b);
2730  vector bool short __tmp2 = __tmp1 |
2731  vec_cmpeq((vector signed short)__tmp1, __a) |
2732  vec_cmpeq((vector signed short)__tmp1, __b);
2733 
2734  vector unsigned long long __res =
2735 #ifdef __LITTLE_ENDIAN__
2736  vec_cnttz((vector unsigned long long)__tmp2);
2737 #else
2738  vec_cntlz((vector unsigned long long)__tmp2);
2739 #endif
2740  if (__res[0] == 64) {
2741  return (__res[1] + 64) >> 4;
2742  }
2743  return __res[0] >> 4;
2744 }
2745 
2746 static __inline__ unsigned __ATTRS_o_ai
2747 vec_first_match_or_eos_index(vector unsigned short __a,
2748  vector unsigned short __b) {
2749  vector bool short __tmp1 = vec_cmpeq(__a, __b);
2750  vector bool short __tmp2 = __tmp1 |
2751  vec_cmpeq((vector unsigned short)__tmp1, __a) |
2752  vec_cmpeq((vector unsigned short)__tmp1, __b);
2753 
2754  vector unsigned long long __res =
2755 #ifdef __LITTLE_ENDIAN__
2756  vec_cnttz((vector unsigned long long)__tmp2);
2757 #else
2758  vec_cntlz((vector unsigned long long)__tmp2);
2759 #endif
2760  if (__res[0] == 64) {
2761  return (__res[1] + 64) >> 4;
2762  }
2763  return __res[0] >> 4;
2764 }
2765 
2766 static __inline__ unsigned __ATTRS_o_ai
2767 vec_first_match_or_eos_index(vector signed int __a, vector signed int __b) {
2768  vector bool int __tmp1 = vec_cmpeq(__a, __b);
2769  vector bool int __tmp2 = __tmp1 | vec_cmpeq((vector signed int)__tmp1, __a) |
2770  vec_cmpeq((vector signed int)__tmp1, __b);
2771 
2772  vector unsigned long long __res =
2773 #ifdef __LITTLE_ENDIAN__
2774  vec_cnttz((vector unsigned long long)__tmp2);
2775 #else
2776  vec_cntlz((vector unsigned long long)__tmp2);
2777 #endif
2778  if (__res[0] == 64) {
2779  return (__res[1] + 64) >> 5;
2780  }
2781  return __res[0] >> 5;
2782 }
2783 
2784 static __inline__ unsigned __ATTRS_o_ai
2785 vec_first_match_or_eos_index(vector unsigned int __a, vector unsigned int __b) {
2786  vector bool int __tmp1 = vec_cmpeq(__a, __b);
2787  vector bool int __tmp2 = __tmp1 |
2788  vec_cmpeq((vector unsigned int)__tmp1, __a) |
2789  vec_cmpeq((vector unsigned int)__tmp1, __b);
2790 
2791  vector unsigned long long __res =
2792 #ifdef __LITTLE_ENDIAN__
2793  vec_cnttz((vector unsigned long long)__tmp2);
2794 #else
2795  vec_cntlz((vector unsigned long long)__tmp2);
2796 #endif
2797  if (__res[0] == 64) {
2798  return (__res[1] + 64) >> 5;
2799  }
2800  return __res[0] >> 5;
2801 }
2802 
2803 /* vec_first_mismatch_index */
2804 
2805 static __inline__ unsigned __ATTRS_o_ai
2806 vec_first_mismatch_index(vector signed char __a, vector signed char __b) {
2807  vector unsigned long long __res =
2808 #ifdef __LITTLE_ENDIAN__
2809  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2810 #else
2811  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2812 #endif
2813  if (__res[0] == 64) {
2814  return (__res[1] + 64) >> 3;
2815  }
2816  return __res[0] >> 3;
2817 }
2818 
2819 static __inline__ unsigned __ATTRS_o_ai
2820 vec_first_mismatch_index(vector unsigned char __a, vector unsigned char __b) {
2821  vector unsigned long long __res =
2822 #ifdef __LITTLE_ENDIAN__
2823  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2824 #else
2825  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2826 #endif
2827  if (__res[0] == 64) {
2828  return (__res[1] + 64) >> 3;
2829  }
2830  return __res[0] >> 3;
2831 }
2832 
2833 static __inline__ unsigned __ATTRS_o_ai
2834 vec_first_mismatch_index(vector signed short __a, vector signed short __b) {
2835  vector unsigned long long __res =
2836 #ifdef __LITTLE_ENDIAN__
2837  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2838 #else
2839  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2840 #endif
2841  if (__res[0] == 64) {
2842  return (__res[1] + 64) >> 4;
2843  }
2844  return __res[0] >> 4;
2845 }
2846 
2847 static __inline__ unsigned __ATTRS_o_ai
2848 vec_first_mismatch_index(vector unsigned short __a, vector unsigned short __b) {
2849  vector unsigned long long __res =
2850 #ifdef __LITTLE_ENDIAN__
2851  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2852 #else
2853  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2854 #endif
2855  if (__res[0] == 64) {
2856  return (__res[1] + 64) >> 4;
2857  }
2858  return __res[0] >> 4;
2859 }
2860 
2861 static __inline__ unsigned __ATTRS_o_ai
2862 vec_first_mismatch_index(vector signed int __a, vector signed int __b) {
2863  vector unsigned long long __res =
2864 #ifdef __LITTLE_ENDIAN__
2865  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2866 #else
2867  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2868 #endif
2869  if (__res[0] == 64) {
2870  return (__res[1] + 64) >> 5;
2871  }
2872  return __res[0] >> 5;
2873 }
2874 
2875 static __inline__ unsigned __ATTRS_o_ai
2876 vec_first_mismatch_index(vector unsigned int __a, vector unsigned int __b) {
2877  vector unsigned long long __res =
2878 #ifdef __LITTLE_ENDIAN__
2879  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2880 #else
2881  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2882 #endif
2883  if (__res[0] == 64) {
2884  return (__res[1] + 64) >> 5;
2885  }
2886  return __res[0] >> 5;
2887 }
2888 
2889 /* vec_first_mismatch_or_eos_index */
2890 
2891 static __inline__ unsigned __ATTRS_o_ai
2892 vec_first_mismatch_or_eos_index(vector signed char __a,
2893  vector signed char __b) {
2894  vector unsigned long long __res =
2895 #ifdef __LITTLE_ENDIAN__
2896  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2897 #else
2898  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2899 #endif
2900  if (__res[0] == 64) {
2901  return (__res[1] + 64) >> 3;
2902  }
2903  return __res[0] >> 3;
2904 }
2905 
2906 static __inline__ unsigned __ATTRS_o_ai
2907 vec_first_mismatch_or_eos_index(vector unsigned char __a,
2908  vector unsigned char __b) {
2909  vector unsigned long long __res =
2910 #ifdef __LITTLE_ENDIAN__
2911  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2912 #else
2913  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2914 #endif
2915  if (__res[0] == 64) {
2916  return (__res[1] + 64) >> 3;
2917  }
2918  return __res[0] >> 3;
2919 }
2920 
2921 static __inline__ unsigned __ATTRS_o_ai
2922 vec_first_mismatch_or_eos_index(vector signed short __a,
2923  vector signed short __b) {
2924  vector unsigned long long __res =
2925 #ifdef __LITTLE_ENDIAN__
2926  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2927 #else
2928  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2929 #endif
2930  if (__res[0] == 64) {
2931  return (__res[1] + 64) >> 4;
2932  }
2933  return __res[0] >> 4;
2934 }
2935 
2936 static __inline__ unsigned __ATTRS_o_ai
2937 vec_first_mismatch_or_eos_index(vector unsigned short __a,
2938  vector unsigned short __b) {
2939  vector unsigned long long __res =
2940 #ifdef __LITTLE_ENDIAN__
2941  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2942 #else
2943  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2944 #endif
2945  if (__res[0] == 64) {
2946  return (__res[1] + 64) >> 4;
2947  }
2948  return __res[0] >> 4;
2949 }
2950 
2951 static __inline__ unsigned __ATTRS_o_ai
2952 vec_first_mismatch_or_eos_index(vector signed int __a, vector signed int __b) {
2953  vector unsigned long long __res =
2954 #ifdef __LITTLE_ENDIAN__
2955  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2956 #else
2957  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2958 #endif
2959  if (__res[0] == 64) {
2960  return (__res[1] + 64) >> 5;
2961  }
2962  return __res[0] >> 5;
2963 }
2964 
2965 static __inline__ unsigned __ATTRS_o_ai
2966 vec_first_mismatch_or_eos_index(vector unsigned int __a,
2967  vector unsigned int __b) {
2968  vector unsigned long long __res =
2969 #ifdef __LITTLE_ENDIAN__
2970  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2971 #else
2972  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2973 #endif
2974  if (__res[0] == 64) {
2975  return (__res[1] + 64) >> 5;
2976  }
2977  return __res[0] >> 5;
2978 }
2979 
2980 static __inline__ vector double __ATTRS_o_ai
2981 vec_insert_exp(vector double __a, vector unsigned long long __b) {
2982  return __builtin_vsx_xviexpdp((vector unsigned long long)__a,__b);
2983 }
2984 
2985 static __inline__ vector double __ATTRS_o_ai
2986 vec_insert_exp(vector unsigned long long __a, vector unsigned long long __b) {
2987  return __builtin_vsx_xviexpdp(__a,__b);
2988 }
2989 
2990 static __inline__ vector float __ATTRS_o_ai
2991 vec_insert_exp(vector float __a, vector unsigned int __b) {
2992  return __builtin_vsx_xviexpsp((vector unsigned int)__a,__b);
2993 }
2994 
2995 static __inline__ vector float __ATTRS_o_ai
2996 vec_insert_exp(vector unsigned int __a, vector unsigned int __b) {
2997  return __builtin_vsx_xviexpsp(__a,__b);
2998 }
2999 
3000 #if defined(__powerpc64__)
3001 static __inline__ vector signed char __ATTRS_o_ai vec_xl_len(const signed char *__a,
3002  size_t __b) {
3003  return (vector signed char)__builtin_vsx_lxvl(__a, (__b << 56));
3004 }
3005 
3006 static __inline__ vector unsigned char __ATTRS_o_ai
3007 vec_xl_len(const unsigned char *__a, size_t __b) {
3008  return (vector unsigned char)__builtin_vsx_lxvl(__a, (__b << 56));
3009 }
3010 
3011 static __inline__ vector signed short __ATTRS_o_ai vec_xl_len(const signed short *__a,
3012  size_t __b) {
3013  return (vector signed short)__builtin_vsx_lxvl(__a, (__b << 56));
3014 }
3015 
3016 static __inline__ vector unsigned short __ATTRS_o_ai
3017 vec_xl_len(const unsigned short *__a, size_t __b) {
3018  return (vector unsigned short)__builtin_vsx_lxvl(__a, (__b << 56));
3019 }
3020 
3021 static __inline__ vector signed int __ATTRS_o_ai vec_xl_len(const signed int *__a,
3022  size_t __b) {
3023  return (vector signed int)__builtin_vsx_lxvl(__a, (__b << 56));
3024 }
3025 
3026 static __inline__ vector unsigned int __ATTRS_o_ai vec_xl_len(const unsigned int *__a,
3027  size_t __b) {
3028  return (vector unsigned int)__builtin_vsx_lxvl(__a, (__b << 56));
3029 }
3030 
3031 static __inline__ vector float __ATTRS_o_ai vec_xl_len(const float *__a, size_t __b) {
3032  return (vector float)__builtin_vsx_lxvl(__a, (__b << 56));
3033 }
3034 
3035 #ifdef __SIZEOF_INT128__
3036 static __inline__ vector signed __int128 __ATTRS_o_ai
3037 vec_xl_len(const signed __int128 *__a, size_t __b) {
3038  return (vector signed __int128)__builtin_vsx_lxvl(__a, (__b << 56));
3039 }
3040 
3041 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3042 vec_xl_len(const unsigned __int128 *__a, size_t __b) {
3043  return (vector unsigned __int128)__builtin_vsx_lxvl(__a, (__b << 56));
3044 }
3045 #endif
3046 
3047 static __inline__ vector signed long long __ATTRS_o_ai
3048 vec_xl_len(const signed long long *__a, size_t __b) {
3049  return (vector signed long long)__builtin_vsx_lxvl(__a, (__b << 56));
3050 }
3051 
3052 static __inline__ vector unsigned long long __ATTRS_o_ai
3053 vec_xl_len(const unsigned long long *__a, size_t __b) {
3054  return (vector unsigned long long)__builtin_vsx_lxvl(__a, (__b << 56));
3055 }
3056 
3057 static __inline__ vector double __ATTRS_o_ai vec_xl_len(const double *__a,
3058  size_t __b) {
3059  return (vector double)__builtin_vsx_lxvl(__a, (__b << 56));
3060 }
3061 
3062 static __inline__ vector unsigned char __ATTRS_o_ai
3063 vec_xl_len_r(const unsigned char *__a, size_t __b) {
3064  vector unsigned char __res =
3065  (vector unsigned char)__builtin_vsx_lxvll(__a, (__b << 56));
3066  vector unsigned char __mask =
3067  (vector unsigned char)__builtin_altivec_lvsr(16 - __b, (int *)NULL);
3068  return (vector unsigned char)__builtin_altivec_vperm_4si(
3069  (vector int)__res, (vector int)__res, __mask);
3070 }
3071 
3072 // vec_xst_len
3073 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned char __a,
3074  unsigned char *__b,
3075  size_t __c) {
3076  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3077 }
3078 
3079 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed char __a,
3080  signed char *__b, size_t __c) {
3081  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3082 }
3083 
3084 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed short __a,
3085  signed short *__b, size_t __c) {
3086  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3087 }
3088 
3089 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned short __a,
3090  unsigned short *__b,
3091  size_t __c) {
3092  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3093 }
3094 
3095 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed int __a,
3096  signed int *__b, size_t __c) {
3097  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3098 }
3099 
3100 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned int __a,
3101  unsigned int *__b, size_t __c) {
3102  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3103 }
3104 
3105 static __inline__ void __ATTRS_o_ai vec_xst_len(vector float __a, float *__b,
3106  size_t __c) {
3107  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3108 }
3109 
3110 #ifdef __SIZEOF_INT128__
3111 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed __int128 __a,
3112  signed __int128 *__b,
3113  size_t __c) {
3114  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3115 }
3116 
3117 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned __int128 __a,
3118  unsigned __int128 *__b,
3119  size_t __c) {
3120  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3121 }
3122 #endif
3123 
3124 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed long long __a,
3125  signed long long *__b,
3126  size_t __c) {
3127  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3128 }
3129 
3130 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned long long __a,
3131  unsigned long long *__b,
3132  size_t __c) {
3133  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3134 }
3135 
3136 static __inline__ void __ATTRS_o_ai vec_xst_len(vector double __a, double *__b,
3137  size_t __c) {
3138  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3139 }
3140 
3141 static __inline__ void __ATTRS_o_ai vec_xst_len_r(vector unsigned char __a,
3142  unsigned char *__b,
3143  size_t __c) {
3144  vector unsigned char __mask =
3145  (vector unsigned char)__builtin_altivec_lvsl(16 - __c, (int *)NULL);
3146  vector unsigned char __res =
3147  __builtin_altivec_vperm_4si((vector int)__a, (vector int)__a, __mask);
3148  return __builtin_vsx_stxvll((vector int)__res, __b, (__c << 56));
3149 }
3150 #endif
3151 #endif
3152 
3153 #if defined(__POWER9_VECTOR__) && defined(__powerpc64__)
3154 #define __vec_ldrmb(PTR, CNT) vec_xl_len_r((const unsigned char *)(PTR), (CNT))
3155 #define __vec_strmb(PTR, CNT, VAL) \
3156  vec_xst_len_r((VAL), (unsigned char *)(PTR), (CNT))
3157 #else
3158 #define __vec_ldrmb __builtin_vsx_ldrmb
3159 #define __vec_strmb __builtin_vsx_strmb
3160 #endif
3161 
3162 /* vec_cpsgn */
3163 
3164 #ifdef __VSX__
3165 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
3166  vector float __b) {
3167  return __builtin_vsx_xvcpsgnsp(__b, __a);
3168 }
3169 
3170 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
3171  vector double __b) {
3172  return __builtin_vsx_xvcpsgndp(__b, __a);
3173 }
3174 #endif
3175 
3176 /* vec_ctf */
3177 
3178 #ifdef __VSX__
3179 // There are some functions that have different signatures with the XL compiler
3180 // from those in Clang/GCC and documented in the PVIPR. This macro ensures that
3181 // the XL-compatible signatures are used for those functions.
3182 #ifdef __XL_COMPAT_ALTIVEC__
3183 #define vec_ctf(__a, __b) \
3184  _Generic((__a), vector int \
3185  : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)), \
3186  vector unsigned int \
3187  : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3188  (__b)), \
3189  vector unsigned long long \
3190  : (__builtin_vsx_xvcvuxdsp((vector unsigned long long)(__a)) * \
3191  (vector float)(vector unsigned)((0x7f - (__b)) << 23)), \
3192  vector signed long long \
3193  : (__builtin_vsx_xvcvsxdsp((vector signed long long)(__a)) * \
3194  (vector float)(vector unsigned)((0x7f - (__b)) << 23)))
3195 #else // __XL_COMPAT_ALTIVEC__
3196 #define vec_ctf(__a, __b) \
3197  _Generic((__a), vector int \
3198  : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)), \
3199  vector unsigned int \
3200  : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3201  (__b)), \
3202  vector unsigned long long \
3203  : (__builtin_convertvector((vector unsigned long long)(__a), \
3204  vector double) * \
3205  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
3206  << 52)), \
3207  vector signed long long \
3208  : (__builtin_convertvector((vector signed long long)(__a), \
3209  vector double) * \
3210  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
3211  << 52)))
3212 #endif // __XL_COMPAT_ALTIVEC__
3213 #else
3214 #define vec_ctf(__a, __b) \
3215  _Generic((__a), vector int \
3216  : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)), \
3217  vector unsigned int \
3218  : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3219  (__b)))
3220 #endif
3221 
3222 /* vec_ctd */
3223 #ifdef __VSX__
3224 #define vec_ctd(__a, __b) \
3225  _Generic((__a), vector signed int \
3226  : (vec_doublee((vector signed int)(__a)) * \
3227  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
3228  << 52)), \
3229  vector unsigned int \
3230  : (vec_doublee((vector unsigned int)(__a)) * \
3231  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
3232  << 52)), \
3233  vector unsigned long long \
3234  : (__builtin_convertvector((vector unsigned long long)(__a), \
3235  vector double) * \
3236  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
3237  << 52)), \
3238  vector signed long long \
3239  : (__builtin_convertvector((vector signed long long)(__a), \
3240  vector double) * \
3241  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
3242  << 52)))
3243 #endif // __VSX__
3244 
3245 /* vec_vcfsx */
3246 
3247 #define vec_vcfux __builtin_altivec_vcfux
3248 /* vec_vcfux */
3249 
3250 #define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
3251 
3252 /* vec_cts */
3253 
3254 #ifdef __VSX__
3255 #ifdef __XL_COMPAT_ALTIVEC__
3256 #define vec_cts(__a, __b) \
3257  _Generic((__a), vector float \
3258  : __builtin_altivec_vctsxs((vector float)(__a), (__b)), \
3259  vector double \
3260  : __extension__({ \
3261  vector double __ret = \
3262  (vector double)(__a) * \
3263  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
3264  << 52); \
3265  __builtin_vsx_xvcvdpsxws(__ret); \
3266  }))
3267 #else // __XL_COMPAT_ALTIVEC__
3268 #define vec_cts(__a, __b) \
3269  _Generic((__a), vector float \
3270  : __builtin_altivec_vctsxs((vector float)(__a), (__b)), \
3271  vector double \
3272  : __extension__({ \
3273  vector double __ret = \
3274  (vector double)(__a) * \
3275  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
3276  << 52); \
3277  __builtin_convertvector(__ret, vector signed long long); \
3278  }))
3279 #endif // __XL_COMPAT_ALTIVEC__
3280 #else
3281 #define vec_cts __builtin_altivec_vctsxs
3282 #endif
3283 
3284 /* vec_vctsxs */
3285 
3286 #define vec_vctsxs __builtin_altivec_vctsxs
3287 
3288 /* vec_ctu */
3289 
3290 #ifdef __VSX__
3291 #ifdef __XL_COMPAT_ALTIVEC__
3292 #define vec_ctu(__a, __b) \
3293  _Generic((__a), vector float \
3294  : __builtin_altivec_vctuxs((vector float)(__a), (__b)), \
3295  vector double \
3296  : __extension__({ \
3297  vector double __ret = \
3298  (vector double)(__a) * \
3299  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
3300  << 52); \
3301  __builtin_vsx_xvcvdpuxws(__ret); \
3302  }))
3303 #else // __XL_COMPAT_ALTIVEC__
3304 #define vec_ctu(__a, __b) \
3305  _Generic((__a), vector float \
3306  : __builtin_altivec_vctuxs((vector float)(__a), (__b)), \
3307  vector double \
3308  : __extension__({ \
3309  vector double __ret = \
3310  (vector double)(__a) * \
3311  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
3312  << 52); \
3313  __builtin_convertvector(__ret, vector unsigned long long); \
3314  }))
3315 #endif // __XL_COMPAT_ALTIVEC__
3316 #else
3317 #define vec_ctu __builtin_altivec_vctuxs
3318 #endif
3319 
3320 #ifdef __LITTLE_ENDIAN__
3321 /* vec_ctsl */
3322 
3323 #ifdef __VSX__
3324 #define vec_ctsl(__a, __b) \
3325  _Generic((__a), vector float \
3326  : __extension__({ \
3327  vector float __ret = \
3328  (vector float)(__a) * \
3329  (vector float)(vector unsigned)((0x7f + (__b)) << 23); \
3330  __builtin_vsx_xvcvspsxds( \
3331  __builtin_vsx_xxsldwi(__ret, __ret, 1)); \
3332  }), \
3333  vector double \
3334  : __extension__({ \
3335  vector double __ret = \
3336  (vector double)(__a) * \
3337  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
3338  << 52); \
3339  __builtin_convertvector(__ret, vector signed long long); \
3340  }))
3341 
3342 /* vec_ctul */
3343 
3344 #define vec_ctul(__a, __b) \
3345  _Generic((__a), vector float \
3346  : __extension__({ \
3347  vector float __ret = \
3348  (vector float)(__a) * \
3349  (vector float)(vector unsigned)((0x7f + (__b)) << 23); \
3350  __builtin_vsx_xvcvspuxds( \
3351  __builtin_vsx_xxsldwi(__ret, __ret, 1)); \
3352  }), \
3353  vector double \
3354  : __extension__({ \
3355  vector double __ret = \
3356  (vector double)(__a) * \
3357  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
3358  << 52); \
3359  __builtin_convertvector(__ret, vector unsigned long long); \
3360  }))
3361 #endif
3362 #else // __LITTLE_ENDIAN__
3363 /* vec_ctsl */
3364 
3365 #ifdef __VSX__
3366 #define vec_ctsl(__a, __b) \
3367  _Generic((__a), vector float \
3368  : __extension__({ \
3369  vector float __ret = \
3370  (vector float)(__a) * \
3371  (vector float)(vector unsigned)((0x7f + (__b)) << 23); \
3372  __builtin_vsx_xvcvspsxds(__ret); \
3373  }), \
3374  vector double \
3375  : __extension__({ \
3376  vector double __ret = \
3377  (vector double)(__a) * \
3378  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
3379  << 52); \
3380  __builtin_convertvector(__ret, vector signed long long); \
3381  }))
3382 
3383 /* vec_ctul */
3384 
3385 #define vec_ctul(__a, __b) \
3386  _Generic((__a), vector float \
3387  : __extension__({ \
3388  vector float __ret = \
3389  (vector float)(__a) * \
3390  (vector float)(vector unsigned)((0x7f + (__b)) << 23); \
3391  __builtin_vsx_xvcvspuxds(__ret); \
3392  }), \
3393  vector double \
3394  : __extension__({ \
3395  vector double __ret = \
3396  (vector double)(__a) * \
3397  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
3398  << 52); \
3399  __builtin_convertvector(__ret, vector unsigned long long); \
3400  }))
3401 #endif
3402 #endif // __LITTLE_ENDIAN__
3403 
3404 /* vec_vctuxs */
3405 
3406 #define vec_vctuxs __builtin_altivec_vctuxs
3407 
3408 /* vec_signext */
3409 
3410 #ifdef __POWER9_VECTOR__
3411 static __inline__ vector signed int __ATTRS_o_ai
3412 vec_signexti(vector signed char __a) {
3413  return __builtin_altivec_vextsb2w(__a);
3414 }
3415 
3416 static __inline__ vector signed int __ATTRS_o_ai
3417 vec_signexti(vector signed short __a) {
3418  return __builtin_altivec_vextsh2w(__a);
3419 }
3420 
3421 static __inline__ vector signed long long __ATTRS_o_ai
3422 vec_signextll(vector signed char __a) {
3423  return __builtin_altivec_vextsb2d(__a);
3424 }
3425 
3426 static __inline__ vector signed long long __ATTRS_o_ai
3427 vec_signextll(vector signed short __a) {
3428  return __builtin_altivec_vextsh2d(__a);
3429 }
3430 
3431 static __inline__ vector signed long long __ATTRS_o_ai
3432 vec_signextll(vector signed int __a) {
3433  return __builtin_altivec_vextsw2d(__a);
3434 }
3435 #endif
3436 
3437 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
3438 static __inline__ vector signed __int128 __ATTRS_o_ai
3439 vec_signextq(vector signed long long __a) {
3440  return __builtin_altivec_vextsd2q(__a);
3441 }
3442 #endif
3443 
3444 /* vec_signed */
3445 
3446 static __inline__ vector signed int __ATTRS_o_ai
3447 vec_sld(vector signed int, vector signed int, unsigned const int __c);
3448 
3449 static __inline__ vector signed int __ATTRS_o_ai
3450 vec_signed(vector float __a) {
3451  return __builtin_convertvector(__a, vector signed int);
3452 }
3453 
3454 #ifdef __VSX__
3455 static __inline__ vector signed long long __ATTRS_o_ai
3456 vec_signed(vector double __a) {
3457  return __builtin_convertvector(__a, vector signed long long);
3458 }
3459 
3460 static __inline__ vector signed int __attribute__((__always_inline__))
3461 vec_signed2(vector double __a, vector double __b) {
3462  return (vector signed int) { __a[0], __a[1], __b[0], __b[1] };
3463 }
3464 
3465 static __inline__ vector signed int __ATTRS_o_ai
3466 vec_signede(vector double __a) {
3467 #ifdef __LITTLE_ENDIAN__
3468  vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3469  return vec_sld(__ret, __ret, 12);
3470 #else
3471  return __builtin_vsx_xvcvdpsxws(__a);
3472 #endif
3473 }
3474 
3475 static __inline__ vector signed int __ATTRS_o_ai
3476 vec_signedo(vector double __a) {
3477 #ifdef __LITTLE_ENDIAN__
3478  return __builtin_vsx_xvcvdpsxws(__a);
3479 #else
3480  vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3481  return vec_sld(__ret, __ret, 12);
3482 #endif
3483 }
3484 #endif
3485 
3486 /* vec_unsigned */
3487 
3488 static __inline__ vector unsigned int __ATTRS_o_ai
3489 vec_sld(vector unsigned int, vector unsigned int, unsigned const int __c);
3490 
3491 static __inline__ vector unsigned int __ATTRS_o_ai
3492 vec_unsigned(vector float __a) {
3493  return __builtin_convertvector(__a, vector unsigned int);
3494 }
3495 
3496 #ifdef __VSX__
3497 static __inline__ vector unsigned long long __ATTRS_o_ai
3498 vec_unsigned(vector double __a) {
3499  return __builtin_convertvector(__a, vector unsigned long long);
3500 }
3501 
3502 static __inline__ vector unsigned int __attribute__((__always_inline__))
3503 vec_unsigned2(vector double __a, vector double __b) {
3504  return (vector unsigned int) { __a[0], __a[1], __b[0], __b[1] };
3505 }
3506 
3507 static __inline__ vector unsigned int __ATTRS_o_ai
3508 vec_unsignede(vector double __a) {
3509 #ifdef __LITTLE_ENDIAN__
3510  vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3511  return vec_sld(__ret, __ret, 12);
3512 #else
3513  return __builtin_vsx_xvcvdpuxws(__a);
3514 #endif
3515 }
3516 
3517 static __inline__ vector unsigned int __ATTRS_o_ai
3518 vec_unsignedo(vector double __a) {
3519 #ifdef __LITTLE_ENDIAN__
3520  return __builtin_vsx_xvcvdpuxws(__a);
3521 #else
3522  vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3523  return vec_sld(__ret, __ret, 12);
3524 #endif
3525 }
3526 #endif
3527 
3528 /* vec_float */
3529 
3530 static __inline__ vector float __ATTRS_o_ai
3531 vec_sld(vector float, vector float, unsigned const int __c);
3532 
3533 static __inline__ vector float __ATTRS_o_ai
3534 vec_float(vector signed int __a) {
3535  return __builtin_convertvector(__a, vector float);
3536 }
3537 
3538 static __inline__ vector float __ATTRS_o_ai
3539 vec_float(vector unsigned int __a) {
3540  return __builtin_convertvector(__a, vector float);
3541 }
3542 
3543 #ifdef __VSX__
3544 static __inline__ vector float __ATTRS_o_ai
3545 vec_float2(vector signed long long __a, vector signed long long __b) {
3546  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3547 }
3548 
3549 static __inline__ vector float __ATTRS_o_ai
3550 vec_float2(vector unsigned long long __a, vector unsigned long long __b) {
3551  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3552 }
3553 
3554 static __inline__ vector float __ATTRS_o_ai
3555 vec_float2(vector double __a, vector double __b) {
3556  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3557 }
3558 
3559 static __inline__ vector float __ATTRS_o_ai
3560 vec_floate(vector signed long long __a) {
3561 #ifdef __LITTLE_ENDIAN__
3562  vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3563  return vec_sld(__ret, __ret, 12);
3564 #else
3565  return __builtin_vsx_xvcvsxdsp(__a);
3566 #endif
3567 }
3568 
3569 static __inline__ vector float __ATTRS_o_ai
3570 vec_floate(vector unsigned long long __a) {
3571 #ifdef __LITTLE_ENDIAN__
3572  vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3573  return vec_sld(__ret, __ret, 12);
3574 #else
3575  return __builtin_vsx_xvcvuxdsp(__a);
3576 #endif
3577 }
3578 
3579 static __inline__ vector float __ATTRS_o_ai
3580 vec_floate(vector double __a) {
3581 #ifdef __LITTLE_ENDIAN__
3582  vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3583  return vec_sld(__ret, __ret, 12);
3584 #else
3585  return __builtin_vsx_xvcvdpsp(__a);
3586 #endif
3587 }
3588 
3589 static __inline__ vector float __ATTRS_o_ai
3590 vec_floato(vector signed long long __a) {
3591 #ifdef __LITTLE_ENDIAN__
3592  return __builtin_vsx_xvcvsxdsp(__a);
3593 #else
3594  vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3595  return vec_sld(__ret, __ret, 12);
3596 #endif
3597 }
3598 
3599 static __inline__ vector float __ATTRS_o_ai
3600 vec_floato(vector unsigned long long __a) {
3601 #ifdef __LITTLE_ENDIAN__
3602  return __builtin_vsx_xvcvuxdsp(__a);
3603 #else
3604  vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3605  return vec_sld(__ret, __ret, 12);
3606 #endif
3607 }
3608 
3609 static __inline__ vector float __ATTRS_o_ai
3610 vec_floato(vector double __a) {
3611 #ifdef __LITTLE_ENDIAN__
3612  return __builtin_vsx_xvcvdpsp(__a);
3613 #else
3614  vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3615  return vec_sld(__ret, __ret, 12);
3616 #endif
3617 }
3618 #endif
3619 
3620 /* vec_double */
3621 
3622 #ifdef __VSX__
3623 static __inline__ vector double __ATTRS_o_ai
3624 vec_double(vector signed long long __a) {
3625  return __builtin_convertvector(__a, vector double);
3626 }
3627 
3628 static __inline__ vector double __ATTRS_o_ai
3629 vec_double(vector unsigned long long __a) {
3630  return __builtin_convertvector(__a, vector double);
3631 }
3632 
3633 static __inline__ vector double __ATTRS_o_ai
3634 vec_doublee(vector signed int __a) {
3635 #ifdef __LITTLE_ENDIAN__
3636  return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3637 #else
3638  return __builtin_vsx_xvcvsxwdp(__a);
3639 #endif
3640 }
3641 
3642 static __inline__ vector double __ATTRS_o_ai
3643 vec_doublee(vector unsigned int __a) {
3644 #ifdef __LITTLE_ENDIAN__
3645  return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3646 #else
3647  return __builtin_vsx_xvcvuxwdp(__a);
3648 #endif
3649 }
3650 
3651 static __inline__ vector double __ATTRS_o_ai
3652 vec_doublee(vector float __a) {
3653 #ifdef __LITTLE_ENDIAN__
3654  return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3655 #else
3656  return __builtin_vsx_xvcvspdp(__a);
3657 #endif
3658 }
3659 
3660 static __inline__ vector double __ATTRS_o_ai
3661 vec_doubleh(vector signed int __a) {
3662  vector double __ret = {__a[0], __a[1]};
3663  return __ret;
3664 }
3665 
3666 static __inline__ vector double __ATTRS_o_ai
3667 vec_doubleh(vector unsigned int __a) {
3668  vector double __ret = {__a[0], __a[1]};
3669  return __ret;
3670 }
3671 
3672 static __inline__ vector double __ATTRS_o_ai
3673 vec_doubleh(vector float __a) {
3674  vector double __ret = {__a[0], __a[1]};
3675  return __ret;
3676 }
3677 
3678 static __inline__ vector double __ATTRS_o_ai
3679 vec_doublel(vector signed int __a) {
3680  vector double __ret = {__a[2], __a[3]};
3681  return __ret;
3682 }
3683 
3684 static __inline__ vector double __ATTRS_o_ai
3685 vec_doublel(vector unsigned int __a) {
3686  vector double __ret = {__a[2], __a[3]};
3687  return __ret;
3688 }
3689 
3690 static __inline__ vector double __ATTRS_o_ai
3691 vec_doublel(vector float __a) {
3692  vector double __ret = {__a[2], __a[3]};
3693  return __ret;
3694 }
3695 
3696 static __inline__ vector double __ATTRS_o_ai
3697 vec_doubleo(vector signed int __a) {
3698 #ifdef __LITTLE_ENDIAN__
3699  return __builtin_vsx_xvcvsxwdp(__a);
3700 #else
3701  return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3702 #endif
3703 }
3704 
3705 static __inline__ vector double __ATTRS_o_ai
3706 vec_doubleo(vector unsigned int __a) {
3707 #ifdef __LITTLE_ENDIAN__
3708  return __builtin_vsx_xvcvuxwdp(__a);
3709 #else
3710  return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3711 #endif
3712 }
3713 
3714 static __inline__ vector double __ATTRS_o_ai
3715 vec_doubleo(vector float __a) {
3716 #ifdef __LITTLE_ENDIAN__
3717  return __builtin_vsx_xvcvspdp(__a);
3718 #else
3719  return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3720 #endif
3721 }
3722 
3723 /* vec_cvf */
3724 static __inline__ vector double __ATTRS_o_ai vec_cvf(vector float __a) {
3725  return vec_doublee(__a);
3726 }
3727 
3728 static __inline__ vector float __ATTRS_o_ai vec_cvf(vector double __a) {
3729  return vec_floate(__a);
3730 }
3731 #endif
3732 
3733 /* vec_div */
3734 
3735 /* Integer vector divides (vectors are scalarized, elements divided
3736  and the vectors reassembled).
3737 */
3738 static __inline__ vector signed char __ATTRS_o_ai
3739 vec_div(vector signed char __a, vector signed char __b) {
3740  return __a / __b;
3741 }
3742 
3743 static __inline__ vector unsigned char __ATTRS_o_ai
3744 vec_div(vector unsigned char __a, vector unsigned char __b) {
3745  return __a / __b;
3746 }
3747 
3748 static __inline__ vector signed short __ATTRS_o_ai
3749 vec_div(vector signed short __a, vector signed short __b) {
3750  return __a / __b;
3751 }
3752 
3753 static __inline__ vector unsigned short __ATTRS_o_ai
3754 vec_div(vector unsigned short __a, vector unsigned short __b) {
3755  return __a / __b;
3756 }
3757 
3758 static __inline__ vector signed int __ATTRS_o_ai
3759 vec_div(vector signed int __a, vector signed int __b) {
3760  return __a / __b;
3761 }
3762 
3763 static __inline__ vector unsigned int __ATTRS_o_ai
3764 vec_div(vector unsigned int __a, vector unsigned int __b) {
3765  return __a / __b;
3766 }
3767 
3768 #ifdef __VSX__
3769 static __inline__ vector signed long long __ATTRS_o_ai
3770 vec_div(vector signed long long __a, vector signed long long __b) {
3771  return __a / __b;
3772 }
3773 
3774 static __inline__ vector unsigned long long __ATTRS_o_ai
3775 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
3776  return __a / __b;
3777 }
3778 
3779 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
3780  vector float __b) {
3781  return __a / __b;
3782 }
3783 
3784 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
3785  vector double __b) {
3786  return __a / __b;
3787 }
3788 #endif
3789 
3790 /* vec_dive */
3791 
3792 #ifdef __POWER10_VECTOR__
3793 static __inline__ vector signed int __ATTRS_o_ai
3794 vec_dive(vector signed int __a, vector signed int __b) {
3795  return __builtin_altivec_vdivesw(__a, __b);
3796 }
3797 
3798 static __inline__ vector unsigned int __ATTRS_o_ai
3799 vec_dive(vector unsigned int __a, vector unsigned int __b) {
3800  return __builtin_altivec_vdiveuw(__a, __b);
3801 }
3802 
3803 static __inline__ vector signed long long __ATTRS_o_ai
3804 vec_dive(vector signed long long __a, vector signed long long __b) {
3805  return __builtin_altivec_vdivesd(__a, __b);
3806 }
3807 
3808 static __inline__ vector unsigned long long __ATTRS_o_ai
3809 vec_dive(vector unsigned long long __a, vector unsigned long long __b) {
3810  return __builtin_altivec_vdiveud(__a, __b);
3811 }
3812 
3813 #ifdef __SIZEOF_INT128__
3814 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3815 vec_dive(vector unsigned __int128 __a, vector unsigned __int128 __b) {
3816  return __builtin_altivec_vdiveuq(__a, __b);
3817 }
3818 
3819 static __inline__ vector signed __int128 __ATTRS_o_ai
3820 vec_dive(vector signed __int128 __a, vector signed __int128 __b) {
3821  return __builtin_altivec_vdivesq(__a, __b);
3822 }
3823 #endif
3824 #endif
3825 
3826 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
3827 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3828 vec_div(vector unsigned __int128 __a, vector unsigned __int128 __b) {
3829  return __a / __b;
3830 }
3831 
3832 static __inline__ vector signed __int128 __ATTRS_o_ai
3833 vec_div(vector signed __int128 __a, vector signed __int128 __b) {
3834  return __a / __b;
3835 }
3836 #endif /* __POWER10_VECTOR__ */
3837 
3838 /* vec_xvtdiv */
3839 
3840 #ifdef __VSX__
3841 static __inline__ int __ATTRS_o_ai vec_test_swdiv(vector double __a,
3842  vector double __b) {
3843  return __builtin_vsx_xvtdivdp(__a, __b);
3844 }
3845 
3846 static __inline__ int __ATTRS_o_ai vec_test_swdivs(vector float __a,
3847  vector float __b) {
3848  return __builtin_vsx_xvtdivsp(__a, __b);
3849 }
3850 #endif
3851 
3852 /* vec_dss */
3853 
3854 #define vec_dss __builtin_altivec_dss
3855 
3856 /* vec_dssall */
3857 
3858 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
3859  __builtin_altivec_dssall();
3860 }
3861 
3862 /* vec_dst */
3863 #define vec_dst(__PTR, __CW, __STR) \
3864  __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR))
3865 
3866 /* vec_dstst */
3867 #define vec_dstst(__PTR, __CW, __STR) \
3868  __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR))
3869 
3870 /* vec_dststt */
3871 #define vec_dststt(__PTR, __CW, __STR) \
3872  __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR))
3873 
3874 /* vec_dstt */
3875 #define vec_dstt(__PTR, __CW, __STR) \
3876  __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR))
3877 
3878 /* vec_eqv */
3879 
3880 #ifdef __POWER8_VECTOR__
3881 static __inline__ vector signed char __ATTRS_o_ai
3882 vec_eqv(vector signed char __a, vector signed char __b) {
3883  return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3884  (vector unsigned int)__b);
3885 }
3886 
3887 static __inline__ vector unsigned char __ATTRS_o_ai
3888 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
3889  return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3890  (vector unsigned int)__b);
3891 }
3892 
3893 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
3894  vector bool char __b) {
3895  return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3896  (vector unsigned int)__b);
3897 }
3898 
3899 static __inline__ vector signed short __ATTRS_o_ai
3900 vec_eqv(vector signed short __a, vector signed short __b) {
3901  return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3902  (vector unsigned int)__b);
3903 }
3904 
3905 static __inline__ vector unsigned short __ATTRS_o_ai
3906 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
3907  return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3908  (vector unsigned int)__b);
3909 }
3910 
3911 static __inline__ vector bool short __ATTRS_o_ai
3912 vec_eqv(vector bool short __a, vector bool short __b) {
3913  return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3914  (vector unsigned int)__b);
3915 }
3916 
3917 static __inline__ vector signed int __ATTRS_o_ai
3918 vec_eqv(vector signed int __a, vector signed int __b) {
3919  return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3920  (vector unsigned int)__b);
3921 }
3922 
3923 static __inline__ vector unsigned int __ATTRS_o_ai
3924 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
3925  return __builtin_vsx_xxleqv(__a, __b);
3926 }
3927 
3928 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
3929  vector bool int __b) {
3930  return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3931  (vector unsigned int)__b);
3932 }
3933 
3934 static __inline__ vector signed long long __ATTRS_o_ai
3935 vec_eqv(vector signed long long __a, vector signed long long __b) {
3936  return (vector signed long long)__builtin_vsx_xxleqv(
3937  (vector unsigned int)__a, (vector unsigned int)__b);
3938 }
3939 
3940 static __inline__ vector unsigned long long __ATTRS_o_ai
3941 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
3942  return (vector unsigned long long)__builtin_vsx_xxleqv(
3943  (vector unsigned int)__a, (vector unsigned int)__b);
3944 }
3945 
3946 static __inline__ vector bool long long __ATTRS_o_ai
3947 vec_eqv(vector bool long long __a, vector bool long long __b) {
3948  return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
3949  (vector unsigned int)__b);
3950 }
3951 
3952 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
3953  vector float __b) {
3954  return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
3955  (vector unsigned int)__b);
3956 }
3957 
3958 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
3959  vector double __b) {
3960  return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
3961  (vector unsigned int)__b);
3962 }
3963 #endif
3964 
3965 /* vec_expte */
3966 
3967 static __inline__ vector float __attribute__((__always_inline__))
3968 vec_expte(vector float __a) {
3969  return __builtin_altivec_vexptefp(__a);
3970 }
3971 
3972 /* vec_vexptefp */
3973 
3974 static __inline__ vector float __attribute__((__always_inline__))
3975 vec_vexptefp(vector float __a) {
3976  return __builtin_altivec_vexptefp(__a);
3977 }
3978 
3979 /* vec_floor */
3980 
3981 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
3982 #ifdef __VSX__
3983  return __builtin_vsx_xvrspim(__a);
3984 #else
3985  return __builtin_altivec_vrfim(__a);
3986 #endif
3987 }
3988 
3989 #ifdef __VSX__
3990 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
3991  return __builtin_vsx_xvrdpim(__a);
3992 }
3993 #endif
3994 
3995 /* vec_roundm */
3996 static __inline__ vector float __ATTRS_o_ai vec_roundm(vector float __a) {
3997  return vec_floor(__a);
3998 }
3999 
4000 #ifdef __VSX__
4001 static __inline__ vector double __ATTRS_o_ai vec_roundm(vector double __a) {
4002  return vec_floor(__a);
4003 }
4004 #endif
4005 
4006 /* vec_vrfim */
4007 
4008 static __inline__ vector float __attribute__((__always_inline__))
4009 vec_vrfim(vector float __a) {
4010  return __builtin_altivec_vrfim(__a);
4011 }
4012 
4013 /* vec_ld */
4014 
4015 static __inline__ vector signed char __ATTRS_o_ai
4016 vec_ld(long __a, const vector signed char *__b) {
4017  return (vector signed char)__builtin_altivec_lvx(__a, __b);
4018 }
4019 
4020 static __inline__ vector signed char __ATTRS_o_ai
4021 vec_ld(long __a, const signed char *__b) {
4022  return (vector signed char)__builtin_altivec_lvx(__a, __b);
4023 }
4024 
4025 static __inline__ vector unsigned char __ATTRS_o_ai
4026 vec_ld(long __a, const vector unsigned char *__b) {
4027  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4028 }
4029 
4030 static __inline__ vector unsigned char __ATTRS_o_ai
4031 vec_ld(long __a, const unsigned char *__b) {
4032  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4033 }
4034 
4035 static __inline__ vector bool char __ATTRS_o_ai
4036 vec_ld(long __a, const vector bool char *__b) {
4037  return (vector bool char)__builtin_altivec_lvx(__a, __b);
4038 }
4039 
4040 static __inline__ vector short __ATTRS_o_ai vec_ld(long __a,
4041  const vector short *__b) {
4042  return (vector short)__builtin_altivec_lvx(__a, __b);
4043 }
4044 
4045 static __inline__ vector short __ATTRS_o_ai vec_ld(long __a, const short *__b) {
4046  return (vector short)__builtin_altivec_lvx(__a, __b);
4047 }
4048 
4049 static __inline__ vector unsigned short __ATTRS_o_ai
4050 vec_ld(long __a, const vector unsigned short *__b) {
4051  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4052 }
4053 
4054 static __inline__ vector unsigned short __ATTRS_o_ai
4055 vec_ld(long __a, const unsigned short *__b) {
4056  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4057 }
4058 
4059 static __inline__ vector bool short __ATTRS_o_ai
4060 vec_ld(long __a, const vector bool short *__b) {
4061  return (vector bool short)__builtin_altivec_lvx(__a, __b);
4062 }
4063 
4064 static __inline__ vector pixel __ATTRS_o_ai vec_ld(long __a,
4065  const vector pixel *__b) {
4066  return (vector pixel)__builtin_altivec_lvx(__a, __b);
4067 }
4068 
4069 static __inline__ vector int __ATTRS_o_ai vec_ld(long __a,
4070  const vector int *__b) {
4071  return (vector int)__builtin_altivec_lvx(__a, __b);
4072 }
4073 
4074 static __inline__ vector int __ATTRS_o_ai vec_ld(long __a, const int *__b) {
4075  return (vector int)__builtin_altivec_lvx(__a, __b);
4076 }
4077 
4078 static __inline__ vector unsigned int __ATTRS_o_ai
4079 vec_ld(long __a, const vector unsigned int *__b) {
4080  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4081 }
4082 
4083 static __inline__ vector unsigned int __ATTRS_o_ai
4084 vec_ld(long __a, const unsigned int *__b) {
4085  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4086 }
4087 
4088 static __inline__ vector bool int __ATTRS_o_ai
4089 vec_ld(long __a, const vector bool int *__b) {
4090  return (vector bool int)__builtin_altivec_lvx(__a, __b);
4091 }
4092 
4093 static __inline__ vector float __ATTRS_o_ai vec_ld(long __a,
4094  const vector float *__b) {
4095  return (vector float)__builtin_altivec_lvx(__a, __b);
4096 }
4097 
4098 static __inline__ vector float __ATTRS_o_ai vec_ld(long __a, const float *__b) {
4099  return (vector float)__builtin_altivec_lvx(__a, __b);
4100 }
4101 
4102 /* vec_lvx */
4103 
4104 static __inline__ vector signed char __ATTRS_o_ai
4105 vec_lvx(long __a, const vector signed char *__b) {
4106  return (vector signed char)__builtin_altivec_lvx(__a, __b);
4107 }
4108 
4109 static __inline__ vector signed char __ATTRS_o_ai
4110 vec_lvx(long __a, const signed char *__b) {
4111  return (vector signed char)__builtin_altivec_lvx(__a, __b);
4112 }
4113 
4114 static __inline__ vector unsigned char __ATTRS_o_ai
4115 vec_lvx(long __a, const vector unsigned char *__b) {
4116  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4117 }
4118 
4119 static __inline__ vector unsigned char __ATTRS_o_ai
4120 vec_lvx(long __a, const unsigned char *__b) {
4121  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4122 }
4123 
4124 static __inline__ vector bool char __ATTRS_o_ai
4125 vec_lvx(long __a, const vector bool char *__b) {
4126  return (vector bool char)__builtin_altivec_lvx(__a, __b);
4127 }
4128 
4129 static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a,
4130  const vector short *__b) {
4131  return (vector short)__builtin_altivec_lvx(__a, __b);
4132 }
4133 
4134 static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a, const short *__b) {
4135  return (vector short)__builtin_altivec_lvx(__a, __b);
4136 }
4137 
4138 static __inline__ vector unsigned short __ATTRS_o_ai
4139 vec_lvx(long __a, const vector unsigned short *__b) {
4140  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4141 }
4142 
4143 static __inline__ vector unsigned short __ATTRS_o_ai
4144 vec_lvx(long __a, const unsigned short *__b) {
4145  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4146 }
4147 
4148 static __inline__ vector bool short __ATTRS_o_ai
4149 vec_lvx(long __a, const vector bool short *__b) {
4150  return (vector bool short)__builtin_altivec_lvx(__a, __b);
4151 }
4152 
4153 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(long __a,
4154  const vector pixel *__b) {
4155  return (vector pixel)__builtin_altivec_lvx(__a, __b);
4156 }
4157 
4158 static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a,
4159  const vector int *__b) {
4160  return (vector int)__builtin_altivec_lvx(__a, __b);
4161 }
4162 
4163 static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a, const int *__b) {
4164  return (vector int)__builtin_altivec_lvx(__a, __b);
4165 }
4166 
4167 static __inline__ vector unsigned int __ATTRS_o_ai
4168 vec_lvx(long __a, const vector unsigned int *__b) {
4169  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4170 }
4171 
4172 static __inline__ vector unsigned int __ATTRS_o_ai
4173 vec_lvx(long __a, const unsigned int *__b) {
4174  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4175 }
4176 
4177 static __inline__ vector bool int __ATTRS_o_ai
4178 vec_lvx(long __a, const vector bool int *__b) {
4179  return (vector bool int)__builtin_altivec_lvx(__a, __b);
4180 }
4181 
4182 static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a,
4183  const vector float *__b) {
4184  return (vector float)__builtin_altivec_lvx(__a, __b);
4185 }
4186 
4187 static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a, const float *__b) {
4188  return (vector float)__builtin_altivec_lvx(__a, __b);
4189 }
4190 
4191 /* vec_lde */
4192 
4193 static __inline__ vector signed char __ATTRS_o_ai
4194 vec_lde(long __a, const signed char *__b) {
4195  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
4196 }
4197 
4198 static __inline__ vector unsigned char __ATTRS_o_ai
4199 vec_lde(long __a, const unsigned char *__b) {
4200  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
4201 }
4202 
4203 static __inline__ vector short __ATTRS_o_ai vec_lde(long __a, const short *__b) {
4204  return (vector short)__builtin_altivec_lvehx(__a, __b);
4205 }
4206 
4207 static __inline__ vector unsigned short __ATTRS_o_ai
4208 vec_lde(long __a, const unsigned short *__b) {
4209  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
4210 }
4211 
4212 static __inline__ vector int __ATTRS_o_ai vec_lde(long __a, const int *__b) {
4213  return (vector int)__builtin_altivec_lvewx(__a, __b);
4214 }
4215 
4216 static __inline__ vector unsigned int __ATTRS_o_ai
4217 vec_lde(long __a, const unsigned int *__b) {
4218  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
4219 }
4220 
4221 static __inline__ vector float __ATTRS_o_ai vec_lde(long __a, const float *__b) {
4222  return (vector float)__builtin_altivec_lvewx(__a, __b);
4223 }
4224 
4225 /* vec_lvebx */
4226 
4227 static __inline__ vector signed char __ATTRS_o_ai
4228 vec_lvebx(long __a, const signed char *__b) {
4229  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
4230 }
4231 
4232 static __inline__ vector unsigned char __ATTRS_o_ai
4233 vec_lvebx(long __a, const unsigned char *__b) {
4234  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
4235 }
4236 
4237 /* vec_lvehx */
4238 
4239 static __inline__ vector short __ATTRS_o_ai vec_lvehx(long __a,
4240  const short *__b) {
4241  return (vector short)__builtin_altivec_lvehx(__a, __b);
4242 }
4243 
4244 static __inline__ vector unsigned short __ATTRS_o_ai
4245 vec_lvehx(long __a, const unsigned short *__b) {
4246  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
4247 }
4248 
4249 /* vec_lvewx */
4250 
4251 static __inline__ vector int __ATTRS_o_ai vec_lvewx(long __a, const int *__b) {
4252  return (vector int)__builtin_altivec_lvewx(__a, __b);
4253 }
4254 
4255 static __inline__ vector unsigned int __ATTRS_o_ai
4256 vec_lvewx(long __a, const unsigned int *__b) {
4257  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
4258 }
4259 
4260 static __inline__ vector float __ATTRS_o_ai vec_lvewx(long __a,
4261  const float *__b) {
4262  return (vector float)__builtin_altivec_lvewx(__a, __b);
4263 }
4264 
4265 /* vec_ldl */
4266 
4267 static __inline__ vector signed char __ATTRS_o_ai
4268 vec_ldl(long __a, const vector signed char *__b) {
4269  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4270 }
4271 
4272 static __inline__ vector signed char __ATTRS_o_ai
4273 vec_ldl(long __a, const signed char *__b) {
4274  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4275 }
4276 
4277 static __inline__ vector unsigned char __ATTRS_o_ai
4278 vec_ldl(long __a, const vector unsigned char *__b) {
4279  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4280 }
4281 
4282 static __inline__ vector unsigned char __ATTRS_o_ai
4283 vec_ldl(long __a, const unsigned char *__b) {
4284  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4285 }
4286 
4287 static __inline__ vector bool char __ATTRS_o_ai
4288 vec_ldl(long __a, const vector bool char *__b) {
4289  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
4290 }
4291 
4292 static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a,
4293  const vector short *__b) {
4294  return (vector short)__builtin_altivec_lvxl(__a, __b);
4295 }
4296 
4297 static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a, const short *__b) {
4298  return (vector short)__builtin_altivec_lvxl(__a, __b);
4299 }
4300 
4301 static __inline__ vector unsigned short __ATTRS_o_ai
4302 vec_ldl(long __a, const vector unsigned short *__b) {
4303  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4304 }
4305 
4306 static __inline__ vector unsigned short __ATTRS_o_ai
4307 vec_ldl(long __a, const unsigned short *__b) {
4308  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4309 }
4310 
4311 static __inline__ vector bool short __ATTRS_o_ai
4312 vec_ldl(long __a, const vector bool short *__b) {
4313  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
4314 }
4315 
4316 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(long __a,
4317  const vector pixel *__b) {
4318  return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
4319 }
4320 
4321 static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a,
4322  const vector int *__b) {
4323  return (vector int)__builtin_altivec_lvxl(__a, __b);
4324 }
4325 
4326 static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a, const int *__b) {
4327  return (vector int)__builtin_altivec_lvxl(__a, __b);
4328 }
4329 
4330 static __inline__ vector unsigned int __ATTRS_o_ai
4331 vec_ldl(long __a, const vector unsigned int *__b) {
4332  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4333 }
4334 
4335 static __inline__ vector unsigned int __ATTRS_o_ai
4336 vec_ldl(long __a, const unsigned int *__b) {
4337  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4338 }
4339 
4340 static __inline__ vector bool int __ATTRS_o_ai
4341 vec_ldl(long __a, const vector bool int *__b) {
4342  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
4343 }
4344 
4345 static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a,
4346  const vector float *__b) {
4347  return (vector float)__builtin_altivec_lvxl(__a, __b);
4348 }
4349 
4350 static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a, const float *__b) {
4351  return (vector float)__builtin_altivec_lvxl(__a, __b);
4352 }
4353 
4354 /* vec_lvxl */
4355 
4356 static __inline__ vector signed char __ATTRS_o_ai
4357 vec_lvxl(long __a, const vector signed char *__b) {
4358  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4359 }
4360 
4361 static __inline__ vector signed char __ATTRS_o_ai
4362 vec_lvxl(long __a, const signed char *__b) {
4363  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4364 }
4365 
4366 static __inline__ vector unsigned char __ATTRS_o_ai
4367 vec_lvxl(long __a, const vector unsigned char *__b) {
4368  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4369 }
4370 
4371 static __inline__ vector unsigned char __ATTRS_o_ai
4372 vec_lvxl(long __a, const unsigned char *__b) {
4373  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4374 }
4375 
4376 static __inline__ vector bool char __ATTRS_o_ai
4377 vec_lvxl(long __a, const vector bool char *__b) {
4378  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
4379 }
4380 
4381 static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
4382  const vector short *__b) {
4383  return (vector short)__builtin_altivec_lvxl(__a, __b);
4384 }
4385 
4386 static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
4387  const short *__b) {
4388  return (vector short)__builtin_altivec_lvxl(__a, __b);
4389 }
4390 
4391 static __inline__ vector unsigned short __ATTRS_o_ai
4392 vec_lvxl(long __a, const vector unsigned short *__b) {
4393  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4394 }
4395 
4396 static __inline__ vector unsigned short __ATTRS_o_ai
4397 vec_lvxl(long __a, const unsigned short *__b) {
4398  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4399 }
4400 
4401 static __inline__ vector bool short __ATTRS_o_ai
4402 vec_lvxl(long __a, const vector bool short *__b) {
4403  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
4404 }
4405 
4406 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(long __a,
4407  const vector pixel *__b) {
4408  return (vector pixel)__builtin_altivec_lvxl(__a, __b);
4409 }
4410 
4411 static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a,
4412  const vector int *__b) {
4413  return (vector int)__builtin_altivec_lvxl(__a, __b);
4414 }
4415 
4416 static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a, const int *__b) {
4417  return (vector int)__builtin_altivec_lvxl(__a, __b);
4418 }
4419 
4420 static __inline__ vector unsigned int __ATTRS_o_ai
4421 vec_lvxl(long __a, const vector unsigned int *__b) {
4422  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4423 }
4424 
4425 static __inline__ vector unsigned int __ATTRS_o_ai
4426 vec_lvxl(long __a, const unsigned int *__b) {
4427  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4428 }
4429 
4430 static __inline__ vector bool int __ATTRS_o_ai
4431 vec_lvxl(long __a, const vector bool int *__b) {
4432  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
4433 }
4434 
4435 static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
4436  const vector float *__b) {
4437  return (vector float)__builtin_altivec_lvxl(__a, __b);
4438 }
4439 
4440 static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
4441  const float *__b) {
4442  return (vector float)__builtin_altivec_lvxl(__a, __b);
4443 }
4444 
4445 /* vec_loge */
4446 
4447 static __inline__ vector float __attribute__((__always_inline__))
4448 vec_loge(vector float __a) {
4449  return __builtin_altivec_vlogefp(__a);
4450 }
4451 
4452 /* vec_vlogefp */
4453 
4454 static __inline__ vector float __attribute__((__always_inline__))
4455 vec_vlogefp(vector float __a) {
4456  return __builtin_altivec_vlogefp(__a);
4457 }
4458 
4459 /* vec_lvsl */
4460 
4461 #ifdef __LITTLE_ENDIAN__
4462 static __inline__ vector unsigned char __ATTRS_o_ai
4463  __attribute__((__deprecated__("use assignment for unaligned little endian \
4464 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
4465  vector unsigned char mask =
4466  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4467  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4468  7, 6, 5, 4, 3, 2, 1, 0};
4469  return vec_perm(mask, mask, reverse);
4470 }
4471 #else
4472 static __inline__ vector unsigned char __ATTRS_o_ai
4473 vec_lvsl(int __a, const signed char *__b) {
4474  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4475 }
4476 #endif
4477 
4478 #ifdef __LITTLE_ENDIAN__
4479 static __inline__ vector unsigned char __ATTRS_o_ai
4480  __attribute__((__deprecated__("use assignment for unaligned little endian \
4481 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
4482  vector unsigned char mask =
4483  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4484  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4485  7, 6, 5, 4, 3, 2, 1, 0};
4486  return vec_perm(mask, mask, reverse);
4487 }
4488 #else
4489 static __inline__ vector unsigned char __ATTRS_o_ai
4490 vec_lvsl(int __a, const unsigned char *__b) {
4491  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4492 }
4493 #endif
4494 
4495 #ifdef __LITTLE_ENDIAN__
4496 static __inline__ vector unsigned char __ATTRS_o_ai
4497  __attribute__((__deprecated__("use assignment for unaligned little endian \
4498 loads/stores"))) vec_lvsl(int __a, const short *__b) {
4499  vector unsigned char mask =
4500  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4501  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4502  7, 6, 5, 4, 3, 2, 1, 0};
4503  return vec_perm(mask, mask, reverse);
4504 }
4505 #else
4506 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4507  const short *__b) {
4508  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4509 }
4510 #endif
4511 
4512 #ifdef __LITTLE_ENDIAN__
4513 static __inline__ vector unsigned char __ATTRS_o_ai
4514  __attribute__((__deprecated__("use assignment for unaligned little endian \
4515 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
4516  vector unsigned char mask =
4517  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4518  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4519  7, 6, 5, 4, 3, 2, 1, 0};
4520  return vec_perm(mask, mask, reverse);
4521 }
4522 #else
4523 static __inline__ vector unsigned char __ATTRS_o_ai
4524 vec_lvsl(int __a, const unsigned short *__b) {
4525  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4526 }
4527 #endif
4528 
4529 #ifdef __LITTLE_ENDIAN__
4530 static __inline__ vector unsigned char __ATTRS_o_ai
4531  __attribute__((__deprecated__("use assignment for unaligned little endian \
4532 loads/stores"))) vec_lvsl(int __a, const int *__b) {
4533  vector unsigned char mask =
4534  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4535  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4536  7, 6, 5, 4, 3, 2, 1, 0};
4537  return vec_perm(mask, mask, reverse);
4538 }
4539 #else
4540 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4541  const int *__b) {
4542  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4543 }
4544 #endif
4545 
4546 #ifdef __LITTLE_ENDIAN__
4547 static __inline__ vector unsigned char __ATTRS_o_ai
4548  __attribute__((__deprecated__("use assignment for unaligned little endian \
4549 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
4550  vector unsigned char mask =
4551  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4552  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4553  7, 6, 5, 4, 3, 2, 1, 0};
4554  return vec_perm(mask, mask, reverse);
4555 }
4556 #else
4557 static __inline__ vector unsigned char __ATTRS_o_ai
4558 vec_lvsl(int __a, const unsigned int *__b) {
4559  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4560 }
4561 #endif
4562 
4563 #ifdef __LITTLE_ENDIAN__
4564 static __inline__ vector unsigned char __ATTRS_o_ai
4565  __attribute__((__deprecated__("use assignment for unaligned little endian \
4566 loads/stores"))) vec_lvsl(int __a, const float *__b) {
4567  vector unsigned char mask =
4568  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4569  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4570  7, 6, 5, 4, 3, 2, 1, 0};
4571  return vec_perm(mask, mask, reverse);
4572 }
4573 #else
4574 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4575  const float *__b) {
4576  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4577 }
4578 #endif
4579 
4580 /* vec_lvsr */
4581 
4582 #ifdef __LITTLE_ENDIAN__
4583 static __inline__ vector unsigned char __ATTRS_o_ai
4584  __attribute__((__deprecated__("use assignment for unaligned little endian \
4585 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
4586  vector unsigned char mask =
4587  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4588  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4589  7, 6, 5, 4, 3, 2, 1, 0};
4590  return vec_perm(mask, mask, reverse);
4591 }
4592 #else
4593 static __inline__ vector unsigned char __ATTRS_o_ai
4594 vec_lvsr(int __a, const signed char *__b) {
4595  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4596 }
4597 #endif
4598 
4599 #ifdef __LITTLE_ENDIAN__
4600 static __inline__ vector unsigned char __ATTRS_o_ai
4601  __attribute__((__deprecated__("use assignment for unaligned little endian \
4602 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
4603  vector unsigned char mask =
4604  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4605  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4606  7, 6, 5, 4, 3, 2, 1, 0};
4607  return vec_perm(mask, mask, reverse);
4608 }
4609 #else
4610 static __inline__ vector unsigned char __ATTRS_o_ai
4611 vec_lvsr(int __a, const unsigned char *__b) {
4612  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4613 }
4614 #endif
4615 
4616 #ifdef __LITTLE_ENDIAN__
4617 static __inline__ vector unsigned char __ATTRS_o_ai
4618  __attribute__((__deprecated__("use assignment for unaligned little endian \
4619 loads/stores"))) vec_lvsr(int __a, const short *__b) {
4620  vector unsigned char mask =
4621  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4622  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4623  7, 6, 5, 4, 3, 2, 1, 0};
4624  return vec_perm(mask, mask, reverse);
4625 }
4626 #else
4627 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4628  const short *__b) {
4629  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4630 }
4631 #endif
4632 
4633 #ifdef __LITTLE_ENDIAN__
4634 static __inline__ vector unsigned char __ATTRS_o_ai
4635  __attribute__((__deprecated__("use assignment for unaligned little endian \
4636 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
4637  vector unsigned char mask =
4638  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4639  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4640  7, 6, 5, 4, 3, 2, 1, 0};
4641  return vec_perm(mask, mask, reverse);
4642 }
4643 #else
4644 static __inline__ vector unsigned char __ATTRS_o_ai
4645 vec_lvsr(int __a, const unsigned short *__b) {
4646  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4647 }
4648 #endif
4649 
4650 #ifdef __LITTLE_ENDIAN__
4651 static __inline__ vector unsigned char __ATTRS_o_ai
4652  __attribute__((__deprecated__("use assignment for unaligned little endian \
4653 loads/stores"))) vec_lvsr(int __a, const int *__b) {
4654  vector unsigned char mask =
4655  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4656  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4657  7, 6, 5, 4, 3, 2, 1, 0};
4658  return vec_perm(mask, mask, reverse);
4659 }
4660 #else
4661 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4662  const int *__b) {
4663  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4664 }
4665 #endif
4666 
4667 #ifdef __LITTLE_ENDIAN__
4668 static __inline__ vector unsigned char __ATTRS_o_ai
4669  __attribute__((__deprecated__("use assignment for unaligned little endian \
4670 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
4671  vector unsigned char mask =
4672  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4673  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4674  7, 6, 5, 4, 3, 2, 1, 0};
4675  return vec_perm(mask, mask, reverse);
4676 }
4677 #else
4678 static __inline__ vector unsigned char __ATTRS_o_ai
4679 vec_lvsr(int __a, const unsigned int *__b) {
4680  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4681 }
4682 #endif
4683 
4684 #ifdef __LITTLE_ENDIAN__
4685 static __inline__ vector unsigned char __ATTRS_o_ai
4686  __attribute__((__deprecated__("use assignment for unaligned little endian \
4687 loads/stores"))) vec_lvsr(int __a, const float *__b) {
4688  vector unsigned char mask =
4689  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4690  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4691  7, 6, 5, 4, 3, 2, 1, 0};
4692  return vec_perm(mask, mask, reverse);
4693 }
4694 #else
4695 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4696  const float *__b) {
4697  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4698 }
4699 #endif
4700 
4701 /* vec_madd */
4702 static __inline__ vector signed short __ATTRS_o_ai
4703 vec_mladd(vector signed short, vector signed short, vector signed short);
4704 static __inline__ vector signed short __ATTRS_o_ai
4705 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
4706 static __inline__ vector signed short __ATTRS_o_ai
4707 vec_mladd(vector unsigned short, vector signed short, vector signed short);
4708 static __inline__ vector unsigned short __ATTRS_o_ai
4709 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
4710 
4711 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
4712  vector signed short __a, vector signed short __b, vector signed short __c) {
4713  return vec_mladd(__a, __b, __c);
4714 }
4715 
4716 static __inline__ vector signed short __ATTRS_o_ai
4717 vec_madd(vector signed short __a, vector unsigned short __b,
4718  vector unsigned short __c) {
4719  return vec_mladd(__a, __b, __c);
4720 }
4721 
4722 static __inline__ vector signed short __ATTRS_o_ai
4723 vec_madd(vector unsigned short __a, vector signed short __b,
4724  vector signed short __c) {
4725  return vec_mladd(__a, __b, __c);
4726 }
4727 
4728 static __inline__ vector unsigned short __ATTRS_o_ai
4729 vec_madd(vector unsigned short __a, vector unsigned short __b,
4730  vector unsigned short __c) {
4731  return vec_mladd(__a, __b, __c);
4732 }
4733 
4734 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
4735  vector float __b,
4736  vector float __c) {
4737 #ifdef __VSX__
4738  return __builtin_vsx_xvmaddasp(__a, __b, __c);
4739 #else
4740  return __builtin_altivec_vmaddfp(__a, __b, __c);
4741 #endif
4742 }
4743 
4744 #ifdef __VSX__
4745 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
4746  vector double __b,
4747  vector double __c) {
4748  return __builtin_vsx_xvmaddadp(__a, __b, __c);
4749 }
4750 #endif
4751 
4752 /* vec_vmaddfp */
4753 
4754 static __inline__ vector float __attribute__((__always_inline__))
4755 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
4756  return __builtin_altivec_vmaddfp(__a, __b, __c);
4757 }
4758 
4759 /* vec_madds */
4760 
4761 static __inline__ vector signed short __attribute__((__always_inline__))
4762 vec_madds(vector signed short __a, vector signed short __b,
4763  vector signed short __c) {
4764  return __builtin_altivec_vmhaddshs(__a, __b, __c);
4765 }
4766 
4767 /* vec_vmhaddshs */
4768 static __inline__ vector signed short __attribute__((__always_inline__))
4769 vec_vmhaddshs(vector signed short __a, vector signed short __b,
4770  vector signed short __c) {
4771  return __builtin_altivec_vmhaddshs(__a, __b, __c);
4772 }
4773 
4774 /* vec_msub */
4775 
4776 #ifdef __VSX__
4777 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
4778  vector float __b,
4779  vector float __c) {
4780  return __builtin_vsx_xvmsubasp(__a, __b, __c);
4781 }
4782 
4783 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
4784  vector double __b,
4785  vector double __c) {
4786  return __builtin_vsx_xvmsubadp(__a, __b, __c);
4787 }
4788 #endif
4789 
4790 /* vec_max */
4791 
4792 static __inline__ vector signed char __ATTRS_o_ai
4793 vec_max(vector signed char __a, vector signed char __b) {
4794  return __builtin_altivec_vmaxsb(__a, __b);
4795 }
4796 
4797 static __inline__ vector signed char __ATTRS_o_ai
4798 vec_max(vector bool char __a, vector signed char __b) {
4799  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4800 }
4801 
4802 static __inline__ vector signed char __ATTRS_o_ai
4803 vec_max(vector signed char __a, vector bool char __b) {
4804  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4805 }
4806 
4807 static __inline__ vector unsigned char __ATTRS_o_ai
4808 vec_max(vector unsigned char __a, vector unsigned char __b) {
4809  return __builtin_altivec_vmaxub(__a, __b);
4810 }
4811 
4812 static __inline__ vector unsigned char __ATTRS_o_ai
4813 vec_max(vector bool char __a, vector unsigned char __b) {
4814  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4815 }
4816 
4817 static __inline__ vector unsigned char __ATTRS_o_ai
4818 vec_max(vector unsigned char __a, vector bool char __b) {
4819  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4820 }
4821 
4822 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4823  vector short __b) {
4824  return __builtin_altivec_vmaxsh(__a, __b);
4825 }
4826 
4827 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
4828  vector short __b) {
4829  return __builtin_altivec_vmaxsh((vector short)__a, __b);
4830 }
4831 
4832 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4833  vector bool short __b) {
4834  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4835 }
4836 
4837 static __inline__ vector unsigned short __ATTRS_o_ai
4838 vec_max(vector unsigned short __a, vector unsigned short __b) {
4839  return __builtin_altivec_vmaxuh(__a, __b);
4840 }
4841 
4842 static __inline__ vector unsigned short __ATTRS_o_ai
4843 vec_max(vector bool short __a, vector unsigned short __b) {
4844  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4845 }
4846 
4847 static __inline__ vector unsigned short __ATTRS_o_ai
4848 vec_max(vector unsigned short __a, vector bool short __b) {
4849  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4850 }
4851 
4852 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4853  vector int __b) {
4854  return __builtin_altivec_vmaxsw(__a, __b);
4855 }
4856 
4857 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
4858  vector int __b) {
4859  return __builtin_altivec_vmaxsw((vector int)__a, __b);
4860 }
4861 
4862 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4863  vector bool int __b) {
4864  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4865 }
4866 
4867 static __inline__ vector unsigned int __ATTRS_o_ai
4868 vec_max(vector unsigned int __a, vector unsigned int __b) {
4869  return __builtin_altivec_vmaxuw(__a, __b);
4870 }
4871 
4872 static __inline__ vector unsigned int __ATTRS_o_ai
4873 vec_max(vector bool int __a, vector unsigned int __b) {
4874  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4875 }
4876 
4877 static __inline__ vector unsigned int __ATTRS_o_ai
4878 vec_max(vector unsigned int __a, vector bool int __b) {
4879  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4880 }
4881 
4882 #ifdef __POWER8_VECTOR__
4883 static __inline__ vector signed long long __ATTRS_o_ai
4884 vec_max(vector signed long long __a, vector signed long long __b) {
4885  return __builtin_altivec_vmaxsd(__a, __b);
4886 }
4887 
4888 static __inline__ vector signed long long __ATTRS_o_ai
4889 vec_max(vector bool long long __a, vector signed long long __b) {
4890  return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
4891 }
4892 
4893 static __inline__ vector signed long long __ATTRS_o_ai
4894 vec_max(vector signed long long __a, vector bool long long __b) {
4895  return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
4896 }
4897 
4898 static __inline__ vector unsigned long long __ATTRS_o_ai
4899 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
4900  return __builtin_altivec_vmaxud(__a, __b);
4901 }
4902 
4903 static __inline__ vector unsigned long long __ATTRS_o_ai
4904 vec_max(vector bool long long __a, vector unsigned long long __b) {
4905  return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
4906 }
4907 
4908 static __inline__ vector unsigned long long __ATTRS_o_ai
4909 vec_max(vector unsigned long long __a, vector bool long long __b) {
4910  return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
4911 }
4912 #endif
4913 
4914 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
4915  vector float __b) {
4916 #ifdef __VSX__
4917  return __builtin_vsx_xvmaxsp(__a, __b);
4918 #else
4919  return __builtin_altivec_vmaxfp(__a, __b);
4920 #endif
4921 }
4922 
4923 #ifdef __VSX__
4924 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
4925  vector double __b) {
4926  return __builtin_vsx_xvmaxdp(__a, __b);
4927 }
4928 #endif
4929 
4930 /* vec_vmaxsb */
4931 
4932 static __inline__ vector signed char __ATTRS_o_ai
4933 vec_vmaxsb(vector signed char __a, vector signed char __b) {
4934  return __builtin_altivec_vmaxsb(__a, __b);
4935 }
4936 
4937 static __inline__ vector signed char __ATTRS_o_ai
4938 vec_vmaxsb(vector bool char __a, vector signed char __b) {
4939  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4940 }
4941 
4942 static __inline__ vector signed char __ATTRS_o_ai
4943 vec_vmaxsb(vector signed char __a, vector bool char __b) {
4944  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4945 }
4946 
4947 /* vec_vmaxub */
4948 
4949 static __inline__ vector unsigned char __ATTRS_o_ai
4950 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
4951  return __builtin_altivec_vmaxub(__a, __b);
4952 }
4953 
4954 static __inline__ vector unsigned char __ATTRS_o_ai
4955 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
4956  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4957 }
4958 
4959 static __inline__ vector unsigned char __ATTRS_o_ai
4960 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
4961  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4962 }
4963 
4964 /* vec_vmaxsh */
4965 
4966 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4967  vector short __b) {
4968  return __builtin_altivec_vmaxsh(__a, __b);
4969 }
4970 
4971 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
4972  vector short __b) {
4973  return __builtin_altivec_vmaxsh((vector short)__a, __b);
4974 }
4975 
4976 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4977  vector bool short __b) {
4978  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4979 }
4980 
4981 /* vec_vmaxuh */
4982 
4983 static __inline__ vector unsigned short __ATTRS_o_ai
4984 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
4985  return __builtin_altivec_vmaxuh(__a, __b);
4986 }
4987 
4988 static __inline__ vector unsigned short __ATTRS_o_ai
4989 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
4990  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4991 }
4992 
4993 static __inline__ vector unsigned short __ATTRS_o_ai
4994 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
4995  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4996 }
4997 
4998 /* vec_vmaxsw */
4999 
5000 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
5001  vector int __b) {
5002  return __builtin_altivec_vmaxsw(__a, __b);
5003 }
5004 
5005 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
5006  vector int __b) {
5007  return __builtin_altivec_vmaxsw((vector int)__a, __b);
5008 }
5009 
5010 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
5011  vector bool int __b) {
5012  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
5013 }
5014 
5015 /* vec_vmaxuw */
5016 
5017 static __inline__ vector unsigned int __ATTRS_o_ai
5018 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
5019  return __builtin_altivec_vmaxuw(__a, __b);
5020 }
5021 
5022 static __inline__ vector unsigned int __ATTRS_o_ai
5023 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
5024  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
5025 }
5026 
5027 static __inline__ vector unsigned int __ATTRS_o_ai
5028 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
5029  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
5030 }
5031 
5032 /* vec_vmaxfp */
5033 
5034 static __inline__ vector float __attribute__((__always_inline__))
5035 vec_vmaxfp(vector float __a, vector float __b) {
5036 #ifdef __VSX__
5037  return __builtin_vsx_xvmaxsp(__a, __b);
5038 #else
5039  return __builtin_altivec_vmaxfp(__a, __b);
5040 #endif
5041 }
5042 
5043 /* vec_mergeh */
5044 
5045 static __inline__ vector signed char __ATTRS_o_ai
5046 vec_mergeh(vector signed char __a, vector signed char __b) {
5047  return vec_perm(__a, __b,
5048  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5049  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5050  0x06, 0x16, 0x07, 0x17));
5051 }
5052 
5053 static __inline__ vector unsigned char __ATTRS_o_ai
5054 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
5055  return vec_perm(__a, __b,
5056  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5057  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5058  0x06, 0x16, 0x07, 0x17));
5059 }
5060 
5061 static __inline__ vector bool char __ATTRS_o_ai
5062 vec_mergeh(vector bool char __a, vector bool char __b) {
5063  return vec_perm(__a, __b,
5064  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5065  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5066  0x06, 0x16, 0x07, 0x17));
5067 }
5068 
5069 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
5070  vector short __b) {
5071  return vec_perm(__a, __b,
5072  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5073  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5074  0x06, 0x07, 0x16, 0x17));
5075 }
5076 
5077 static __inline__ vector unsigned short __ATTRS_o_ai
5078 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
5079  return vec_perm(__a, __b,
5080  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5081  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5082  0x06, 0x07, 0x16, 0x17));
5083 }
5084 
5085 static __inline__ vector bool short __ATTRS_o_ai
5086 vec_mergeh(vector bool short __a, vector bool short __b) {
5087  return vec_perm(__a, __b,
5088  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5089  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5090  0x06, 0x07, 0x16, 0x17));
5091 }
5092 
5093 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
5094  vector pixel __b) {
5095  return vec_perm(__a, __b,
5096  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5097  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5098  0x06, 0x07, 0x16, 0x17));
5099 }
5100 
5101 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
5102  vector int __b) {
5103  return vec_perm(__a, __b,
5104  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5105  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5106  0x14, 0x15, 0x16, 0x17));
5107 }
5108 
5109 static __inline__ vector unsigned int __ATTRS_o_ai
5110 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
5111  return vec_perm(__a, __b,
5112  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5113  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5114  0x14, 0x15, 0x16, 0x17));
5115 }
5116 
5117 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
5118  vector bool int __b) {
5119  return vec_perm(__a, __b,
5120  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5121  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5122  0x14, 0x15, 0x16, 0x17));
5123 }
5124 
5125 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
5126  vector float __b) {
5127  return vec_perm(__a, __b,
5128  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5129  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5130  0x14, 0x15, 0x16, 0x17));
5131 }
5132 
5133 #ifdef __VSX__
5134 static __inline__ vector signed long long __ATTRS_o_ai
5135 vec_mergeh(vector signed long long __a, vector signed long long __b) {
5136  return vec_perm(__a, __b,
5137  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5138  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5139  0x14, 0x15, 0x16, 0x17));
5140 }
5141 
5142 static __inline__ vector signed long long __ATTRS_o_ai
5143 vec_mergeh(vector signed long long __a, vector bool long long __b) {
5144  return vec_perm(__a, (vector signed long long)__b,
5145  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5146  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5147  0x14, 0x15, 0x16, 0x17));
5148 }
5149 
5150 static __inline__ vector signed long long __ATTRS_o_ai
5151 vec_mergeh(vector bool long long __a, vector signed long long __b) {
5152  return vec_perm((vector signed long long)__a, __b,
5153  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5154  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5155  0x14, 0x15, 0x16, 0x17));
5156 }
5157 
5158 static __inline__ vector unsigned long long __ATTRS_o_ai
5159 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
5160  return vec_perm(__a, __b,
5161  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5162  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5163  0x14, 0x15, 0x16, 0x17));
5164 }
5165 
5166 static __inline__ vector unsigned long long __ATTRS_o_ai
5167 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
5168  return vec_perm(__a, (vector unsigned long long)__b,
5169  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5170  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5171  0x14, 0x15, 0x16, 0x17));
5172 }
5173 
5174 static __inline__ vector unsigned long long __ATTRS_o_ai
5175 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
5176  return vec_perm((vector unsigned long long)__a, __b,
5177  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5178  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5179  0x14, 0x15, 0x16, 0x17));
5180 }
5181 
5182 static __inline__ vector bool long long __ATTRS_o_ai
5183 vec_mergeh(vector bool long long __a, vector bool long long __b) {
5184  return vec_perm(__a, __b,
5185  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5186  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5187  0x14, 0x15, 0x16, 0x17));
5188 }
5189 
5190 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
5191  vector double __b) {
5192  return vec_perm(__a, __b,
5193  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5194  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5195  0x14, 0x15, 0x16, 0x17));
5196 }
5197 static __inline__ vector double __ATTRS_o_ai
5198 vec_mergeh(vector double __a, vector bool long long __b) {
5199  return vec_perm(__a, (vector double)__b,
5200  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5201  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5202  0x14, 0x15, 0x16, 0x17));
5203 }
5204 static __inline__ vector double __ATTRS_o_ai
5205 vec_mergeh(vector bool long long __a, vector double __b) {
5206  return vec_perm((vector double)__a, __b,
5207  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5208  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5209  0x14, 0x15, 0x16, 0x17));
5210 }
5211 #endif
5212 
5213 /* vec_vmrghb */
5214 
5215 #define __builtin_altivec_vmrghb vec_vmrghb
5216 
5217 static __inline__ vector signed char __ATTRS_o_ai
5218 vec_vmrghb(vector signed char __a, vector signed char __b) {
5219  return vec_perm(__a, __b,
5220  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5221  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5222  0x06, 0x16, 0x07, 0x17));
5223 }
5224 
5225 static __inline__ vector unsigned char __ATTRS_o_ai
5226 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
5227  return vec_perm(__a, __b,
5228  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5229  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5230  0x06, 0x16, 0x07, 0x17));
5231 }
5232 
5233 static __inline__ vector bool char __ATTRS_o_ai
5234 vec_vmrghb(vector bool char __a, vector bool char __b) {
5235  return vec_perm(__a, __b,
5236  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5237  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5238  0x06, 0x16, 0x07, 0x17));
5239 }
5240 
5241 /* vec_vmrghh */
5242 
5243 #define __builtin_altivec_vmrghh vec_vmrghh
5244 
5245 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
5246  vector short __b) {
5247  return vec_perm(__a, __b,
5248  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5249  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5250  0x06, 0x07, 0x16, 0x17));
5251 }
5252 
5253 static __inline__ vector unsigned short __ATTRS_o_ai
5254 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
5255  return vec_perm(__a, __b,
5256  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5257  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5258  0x06, 0x07, 0x16, 0x17));
5259 }
5260 
5261 static __inline__ vector bool short __ATTRS_o_ai
5262 vec_vmrghh(vector bool short __a, vector bool short __b) {
5263  return vec_perm(__a, __b,
5264  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5265  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5266  0x06, 0x07, 0x16, 0x17));
5267 }
5268 
5269 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
5270  vector pixel __b) {
5271  return vec_perm(__a, __b,
5272  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5273  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5274  0x06, 0x07, 0x16, 0x17));
5275 }
5276 
5277 /* vec_vmrghw */
5278 
5279 #define __builtin_altivec_vmrghw vec_vmrghw
5280 
5281 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
5282  vector int __b) {
5283  return vec_perm(__a, __b,
5284  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5285  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5286  0x14, 0x15, 0x16, 0x17));
5287 }
5288 
5289 static __inline__ vector unsigned int __ATTRS_o_ai
5290 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
5291  return vec_perm(__a, __b,
5292  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5293  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5294  0x14, 0x15, 0x16, 0x17));
5295 }
5296 
5297 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
5298  vector bool int __b) {
5299  return vec_perm(__a, __b,
5300  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5301  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5302  0x14, 0x15, 0x16, 0x17));
5303 }
5304 
5305 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
5306  vector float __b) {
5307  return vec_perm(__a, __b,
5308  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5309  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5310  0x14, 0x15, 0x16, 0x17));
5311 }
5312 
5313 /* vec_mergel */
5314 
5315 static __inline__ vector signed char __ATTRS_o_ai
5316 vec_mergel(vector signed char __a, vector signed char __b) {
5317  return vec_perm(__a, __b,
5318  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5319  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5320  0x0E, 0x1E, 0x0F, 0x1F));
5321 }
5322 
5323 static __inline__ vector unsigned char __ATTRS_o_ai
5324 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
5325  return vec_perm(__a, __b,
5326  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5327  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5328  0x0E, 0x1E, 0x0F, 0x1F));
5329 }
5330 
5331 static __inline__ vector bool char __ATTRS_o_ai
5332 vec_mergel(vector bool char __a, vector bool char __b) {
5333  return vec_perm(__a, __b,
5334  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5335  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5336  0x0E, 0x1E, 0x0F, 0x1F));
5337 }
5338 
5339 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
5340  vector short __b) {
5341  return vec_perm(__a, __b,
5342  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5343  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5344  0x0E, 0x0F, 0x1E, 0x1F));
5345 }
5346 
5347 static __inline__ vector unsigned short __ATTRS_o_ai
5348 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
5349  return vec_perm(__a, __b,
5350  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5351  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5352  0x0E, 0x0F, 0x1E, 0x1F));
5353 }
5354 
5355 static __inline__ vector bool short __ATTRS_o_ai
5356 vec_mergel(vector bool short __a, vector bool short __b) {
5357  return vec_perm(__a, __b,
5358  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5359  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5360  0x0E, 0x0F, 0x1E, 0x1F));
5361 }
5362 
5363 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
5364  vector pixel __b) {
5365  return vec_perm(__a, __b,
5366  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5367  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5368  0x0E, 0x0F, 0x1E, 0x1F));
5369 }
5370 
5371 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
5372  vector int __b) {
5373  return vec_perm(__a, __b,
5374  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5375  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5376  0x1C, 0x1D, 0x1E, 0x1F));
5377 }
5378 
5379 static __inline__ vector unsigned int __ATTRS_o_ai
5380 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
5381  return vec_perm(__a, __b,
5382  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5383  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5384  0x1C, 0x1D, 0x1E, 0x1F));
5385 }
5386 
5387 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
5388  vector bool int __b) {
5389  return vec_perm(__a, __b,
5390  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5391  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5392  0x1C, 0x1D, 0x1E, 0x1F));
5393 }
5394 
5395 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
5396  vector float __b) {
5397  return vec_perm(__a, __b,
5398  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5399  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5400  0x1C, 0x1D, 0x1E, 0x1F));
5401 }
5402 
5403 #ifdef __VSX__
5404 static __inline__ vector signed long long __ATTRS_o_ai
5405 vec_mergel(vector signed long long __a, vector signed long long __b) {
5406  return vec_perm(__a, __b,
5407  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5408  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5409  0x1C, 0x1D, 0x1E, 0x1F));
5410 }
5411 static __inline__ vector signed long long __ATTRS_o_ai
5412 vec_mergel(vector signed long long __a, vector bool long long __b) {
5413  return vec_perm(__a, (vector signed long long)__b,
5414  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5415  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5416  0x1C, 0x1D, 0x1E, 0x1F));
5417 }
5418 static __inline__ vector signed long long __ATTRS_o_ai
5419 vec_mergel(vector bool long long __a, vector signed long long __b) {
5420  return vec_perm((vector signed long long)__a, __b,
5421  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5422  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5423  0x1C, 0x1D, 0x1E, 0x1F));
5424 }
5425 static __inline__ vector unsigned long long __ATTRS_o_ai
5426 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
5427  return vec_perm(__a, __b,
5428  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5429  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5430  0x1C, 0x1D, 0x1E, 0x1F));
5431 }
5432 static __inline__ vector unsigned long long __ATTRS_o_ai
5433 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
5434  return vec_perm(__a, (vector unsigned long long)__b,
5435  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5436  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5437  0x1C, 0x1D, 0x1E, 0x1F));
5438 }
5439 static __inline__ vector unsigned long long __ATTRS_o_ai
5440 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
5441  return vec_perm((vector unsigned long long)__a, __b,
5442  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5443  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5444  0x1C, 0x1D, 0x1E, 0x1F));
5445 }
5446 static __inline__ vector bool long long __ATTRS_o_ai
5447 vec_mergel(vector bool long long __a, vector bool long long __b) {
5448  return vec_perm(__a, __b,
5449  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5450  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5451  0x1C, 0x1D, 0x1E, 0x1F));
5452 }
5453 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
5454  vector double __b) {
5455  return vec_perm(__a, __b,
5456  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5457  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5458  0x1C, 0x1D, 0x1E, 0x1F));
5459 }
5460 static __inline__ vector double __ATTRS_o_ai
5461 vec_mergel(vector double __a, vector bool long long __b) {
5462  return vec_perm(__a, (vector double)__b,
5463  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5464  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5465  0x1C, 0x1D, 0x1E, 0x1F));
5466 }
5467 static __inline__ vector double __ATTRS_o_ai
5468 vec_mergel(vector bool long long __a, vector double __b) {
5469  return vec_perm((vector double)__a, __b,
5470  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5471  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5472  0x1C, 0x1D, 0x1E, 0x1F));
5473 }
5474 #endif
5475 
5476 /* vec_vmrglb */
5477 
5478 #define __builtin_altivec_vmrglb vec_vmrglb
5479 
5480 static __inline__ vector signed char __ATTRS_o_ai
5481 vec_vmrglb(vector signed char __a, vector signed char __b) {
5482  return vec_perm(__a, __b,
5483  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5484  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5485  0x0E, 0x1E, 0x0F, 0x1F));
5486 }
5487 
5488 static __inline__ vector unsigned char __ATTRS_o_ai
5489 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
5490  return vec_perm(__a, __b,
5491  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5492  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5493  0x0E, 0x1E, 0x0F, 0x1F));
5494 }
5495 
5496 static __inline__ vector bool char __ATTRS_o_ai
5497 vec_vmrglb(vector bool char __a, vector bool char __b) {
5498  return vec_perm(__a, __b,
5499  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5500  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5501  0x0E, 0x1E, 0x0F, 0x1F));
5502 }
5503 
5504 /* vec_vmrglh */
5505 
5506 #define __builtin_altivec_vmrglh vec_vmrglh
5507 
5508 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
5509  vector short __b) {
5510  return vec_perm(__a, __b,
5511  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5512  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5513  0x0E, 0x0F, 0x1E, 0x1F));
5514 }
5515 
5516 static __inline__ vector unsigned short __ATTRS_o_ai
5517 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
5518  return vec_perm(__a, __b,
5519  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5520  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5521  0x0E, 0x0F, 0x1E, 0x1F));
5522 }
5523 
5524 static __inline__ vector bool short __ATTRS_o_ai
5525 vec_vmrglh(vector bool short __a, vector bool short __b) {
5526  return vec_perm(__a, __b,
5527  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5528  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5529  0x0E, 0x0F, 0x1E, 0x1F));
5530 }
5531 
5532 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
5533  vector pixel __b) {
5534  return vec_perm(__a, __b,
5535  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5536  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5537  0x0E, 0x0F, 0x1E, 0x1F));
5538 }
5539 
5540 /* vec_vmrglw */
5541 
5542 #define __builtin_altivec_vmrglw vec_vmrglw
5543 
5544 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
5545  vector int __b) {
5546  return vec_perm(__a, __b,
5547  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5548  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5549  0x1C, 0x1D, 0x1E, 0x1F));
5550 }
5551 
5552 static __inline__ vector unsigned int __ATTRS_o_ai
5553 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
5554  return vec_perm(__a, __b,
5555  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5556  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5557  0x1C, 0x1D, 0x1E, 0x1F));
5558 }
5559 
5560 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
5561  vector bool int __b) {
5562  return vec_perm(__a, __b,
5563  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5564  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5565  0x1C, 0x1D, 0x1E, 0x1F));
5566 }
5567 
5568 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
5569  vector float __b) {
5570  return vec_perm(__a, __b,
5571  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5572  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5573  0x1C, 0x1D, 0x1E, 0x1F));
5574 }
5575 
5576 #ifdef __POWER8_VECTOR__
5577 /* vec_mergee */
5578 
5579 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
5580  vector bool int __b) {
5581  return vec_perm(__a, __b,
5582  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5583  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5584  0x18, 0x19, 0x1A, 0x1B));
5585 }
5586 
5587 static __inline__ vector signed int __ATTRS_o_ai
5588 vec_mergee(vector signed int __a, vector signed int __b) {
5589  return vec_perm(__a, __b,
5590  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5591  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5592  0x18, 0x19, 0x1A, 0x1B));
5593 }
5594 
5595 static __inline__ vector unsigned int __ATTRS_o_ai
5596 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
5597  return vec_perm(__a, __b,
5598  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5599  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5600  0x18, 0x19, 0x1A, 0x1B));
5601 }
5602 
5603 static __inline__ vector bool long long __ATTRS_o_ai
5604 vec_mergee(vector bool long long __a, vector bool long long __b) {
5605  return vec_mergeh(__a, __b);
5606 }
5607 
5608 static __inline__ vector signed long long __ATTRS_o_ai
5609 vec_mergee(vector signed long long __a, vector signed long long __b) {
5610  return vec_mergeh(__a, __b);
5611 }
5612 
5613 static __inline__ vector unsigned long long __ATTRS_o_ai
5614 vec_mergee(vector unsigned long long __a, vector unsigned long long __b) {
5615  return vec_mergeh(__a, __b);
5616 }
5617 
5618 static __inline__ vector float __ATTRS_o_ai
5619 vec_mergee(vector float __a, vector float __b) {
5620  return vec_perm(__a, __b,
5621  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5622  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5623  0x18, 0x19, 0x1A, 0x1B));
5624 }
5625 
5626 static __inline__ vector double __ATTRS_o_ai
5627 vec_mergee(vector double __a, vector double __b) {
5628  return vec_mergeh(__a, __b);
5629 }
5630 
5631 /* vec_mergeo */
5632 
5633 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
5634  vector bool int __b) {
5635  return vec_perm(__a, __b,
5636  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5637  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5638  0x1C, 0x1D, 0x1E, 0x1F));
5639 }
5640 
5641 static __inline__ vector signed int __ATTRS_o_ai
5642 vec_mergeo(vector signed int __a, vector signed int __b) {
5643  return vec_perm(__a, __b,
5644  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5645  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5646  0x1C, 0x1D, 0x1E, 0x1F));
5647 }
5648 
5649 static __inline__ vector unsigned int __ATTRS_o_ai
5650 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
5651  return vec_perm(__a, __b,
5652  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5653  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5654  0x1C, 0x1D, 0x1E, 0x1F));
5655 }
5656 
5657 static __inline__ vector bool long long __ATTRS_o_ai
5658 vec_mergeo(vector bool long long __a, vector bool long long __b) {
5659  return vec_mergel(__a, __b);
5660 }
5661 
5662 static __inline__ vector signed long long __ATTRS_o_ai
5663 vec_mergeo(vector signed long long __a, vector signed long long __b) {
5664  return vec_mergel(__a, __b);
5665 }
5666 
5667 static __inline__ vector unsigned long long __ATTRS_o_ai
5668 vec_mergeo(vector unsigned long long __a, vector unsigned long long __b) {
5669  return vec_mergel(__a, __b);
5670 }
5671 
5672 static __inline__ vector float __ATTRS_o_ai
5673 vec_mergeo(vector float __a, vector float __b) {
5674  return vec_perm(__a, __b,
5675  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5676  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5677  0x1C, 0x1D, 0x1E, 0x1F));
5678 }
5679 
5680 static __inline__ vector double __ATTRS_o_ai
5681 vec_mergeo(vector double __a, vector double __b) {
5682  return vec_mergel(__a, __b);
5683 }
5684 
5685 #endif
5686 
5687 /* vec_mfvscr */
5688 
5689 static __inline__ vector unsigned short __attribute__((__always_inline__))
5690 vec_mfvscr(void) {
5691  return __builtin_altivec_mfvscr();
5692 }
5693 
5694 /* vec_min */
5695 
5696 static __inline__ vector signed char __ATTRS_o_ai
5697 vec_min(vector signed char __a, vector signed char __b) {
5698  return __builtin_altivec_vminsb(__a, __b);
5699 }
5700 
5701 static __inline__ vector signed char __ATTRS_o_ai
5702 vec_min(vector bool char __a, vector signed char __b) {
5703  return __builtin_altivec_vminsb((vector signed char)__a, __b);
5704 }
5705 
5706 static __inline__ vector signed char __ATTRS_o_ai
5707 vec_min(vector signed char __a, vector bool char __b) {
5708  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5709 }
5710 
5711 static __inline__ vector unsigned char __ATTRS_o_ai
5712 vec_min(vector unsigned char __a, vector unsigned char __b) {
5713  return __builtin_altivec_vminub(__a, __b);
5714 }
5715 
5716 static __inline__ vector unsigned char __ATTRS_o_ai
5717 vec_min(vector bool char __a, vector unsigned char __b) {
5718  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5719 }
5720 
5721 static __inline__ vector unsigned char __ATTRS_o_ai
5722 vec_min(vector unsigned char __a, vector bool char __b) {
5723  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5724 }
5725 
5726 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5727  vector short __b) {
5728  return __builtin_altivec_vminsh(__a, __b);
5729 }
5730 
5731 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
5732  vector short __b) {
5733  return __builtin_altivec_vminsh((vector short)__a, __b);
5734 }
5735 
5736 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5737  vector bool short __b) {
5738  return __builtin_altivec_vminsh(__a, (vector short)__b);
5739 }
5740 
5741 static __inline__ vector unsigned short __ATTRS_o_ai
5742 vec_min(vector unsigned short __a, vector unsigned short __b) {
5743  return __builtin_altivec_vminuh(__a, __b);
5744 }
5745 
5746 static __inline__ vector unsigned short __ATTRS_o_ai
5747 vec_min(vector bool short __a, vector unsigned short __b) {
5748  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5749 }
5750 
5751 static __inline__ vector unsigned short __ATTRS_o_ai
5752 vec_min(vector unsigned short __a, vector bool short __b) {
5753  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5754 }
5755 
5756 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5757  vector int __b) {
5758  return __builtin_altivec_vminsw(__a, __b);
5759 }
5760 
5761 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
5762  vector int __b) {
5763  return __builtin_altivec_vminsw((vector int)__a, __b);
5764 }
5765 
5766 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5767  vector bool int __b) {
5768  return __builtin_altivec_vminsw(__a, (vector int)__b);
5769 }
5770 
5771 static __inline__ vector unsigned int __ATTRS_o_ai
5772 vec_min(vector unsigned int __a, vector unsigned int __b) {
5773  return __builtin_altivec_vminuw(__a, __b);
5774 }
5775 
5776 static __inline__ vector unsigned int __ATTRS_o_ai
5777 vec_min(vector bool int __a, vector unsigned int __b) {
5778  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5779 }
5780 
5781 static __inline__ vector unsigned int __ATTRS_o_ai
5782 vec_min(vector unsigned int __a, vector bool int __b) {
5783  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5784 }
5785 
5786 #ifdef __POWER8_VECTOR__
5787 static __inline__ vector signed long long __ATTRS_o_ai
5788 vec_min(vector signed long long __a, vector signed long long __b) {
5789  return __builtin_altivec_vminsd(__a, __b);
5790 }
5791 
5792 static __inline__ vector signed long long __ATTRS_o_ai
5793 vec_min(vector bool long long __a, vector signed long long __b) {
5794  return __builtin_altivec_vminsd((vector signed long long)__a, __b);
5795 }
5796 
5797 static __inline__ vector signed long long __ATTRS_o_ai
5798 vec_min(vector signed long long __a, vector bool long long __b) {
5799  return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
5800 }
5801 
5802 static __inline__ vector unsigned long long __ATTRS_o_ai
5803 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
5804  return __builtin_altivec_vminud(__a, __b);
5805 }
5806 
5807 static __inline__ vector unsigned long long __ATTRS_o_ai
5808 vec_min(vector bool long long __a, vector unsigned long long __b) {
5809  return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
5810 }
5811 
5812 static __inline__ vector unsigned long long __ATTRS_o_ai
5813 vec_min(vector unsigned long long __a, vector bool long long __b) {
5814  return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
5815 }
5816 #endif
5817 
5818 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
5819  vector float __b) {
5820 #ifdef __VSX__
5821  return __builtin_vsx_xvminsp(__a, __b);
5822 #else
5823  return __builtin_altivec_vminfp(__a, __b);
5824 #endif
5825 }
5826 
5827 #ifdef __VSX__
5828 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
5829  vector double __b) {
5830  return __builtin_vsx_xvmindp(__a, __b);
5831 }
5832 #endif
5833 
5834 /* vec_vminsb */
5835 
5836 static __inline__ vector signed char __ATTRS_o_ai
5837 vec_vminsb(vector signed char __a, vector signed char __b) {
5838  return __builtin_altivec_vminsb(__a, __b);
5839 }
5840 
5841 static __inline__ vector signed char __ATTRS_o_ai
5842 vec_vminsb(vector bool char __a, vector signed char __b) {
5843  return __builtin_altivec_vminsb((vector signed char)__a, __b);
5844 }
5845 
5846 static __inline__ vector signed char __ATTRS_o_ai
5847 vec_vminsb(vector signed char __a, vector bool char __b) {
5848  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5849 }
5850 
5851 /* vec_vminub */
5852 
5853 static __inline__ vector unsigned char __ATTRS_o_ai
5854 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
5855  return __builtin_altivec_vminub(__a, __b);
5856 }
5857 
5858 static __inline__ vector unsigned char __ATTRS_o_ai
5859 vec_vminub(vector bool char __a, vector unsigned char __b) {
5860  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5861 }
5862 
5863 static __inline__ vector unsigned char __ATTRS_o_ai
5864 vec_vminub(vector unsigned char __a, vector bool char __b) {
5865  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5866 }
5867 
5868 /* vec_vminsh */
5869 
5870 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5871  vector short __b) {
5872  return __builtin_altivec_vminsh(__a, __b);
5873 }
5874 
5875 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
5876  vector short __b) {
5877  return __builtin_altivec_vminsh((vector short)__a, __b);
5878 }
5879 
5880 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5881  vector bool short __b) {
5882  return __builtin_altivec_vminsh(__a, (vector short)__b);
5883 }
5884 
5885 /* vec_vminuh */
5886 
5887 static __inline__ vector unsigned short __ATTRS_o_ai
5888 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
5889  return __builtin_altivec_vminuh(__a, __b);
5890 }
5891 
5892 static __inline__ vector unsigned short __ATTRS_o_ai
5893 vec_vminuh(vector bool short __a, vector unsigned short __b) {
5894  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5895 }
5896 
5897 static __inline__ vector unsigned short __ATTRS_o_ai
5898 vec_vminuh(vector unsigned short __a, vector bool short __b) {
5899  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5900 }
5901 
5902 /* vec_vminsw */
5903 
5904 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5905  vector int __b) {
5906  return __builtin_altivec_vminsw(__a, __b);
5907 }
5908 
5909 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
5910  vector int __b) {
5911  return __builtin_altivec_vminsw((vector int)__a, __b);
5912 }
5913 
5914 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5915  vector bool int __b) {
5916  return __builtin_altivec_vminsw(__a, (vector int)__b);
5917 }
5918 
5919 /* vec_vminuw */
5920 
5921 static __inline__ vector unsigned int __ATTRS_o_ai
5922 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
5923  return __builtin_altivec_vminuw(__a, __b);
5924 }
5925 
5926 static __inline__ vector unsigned int __ATTRS_o_ai
5927 vec_vminuw(vector bool int __a, vector unsigned int __b) {
5928  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5929 }
5930 
5931 static __inline__ vector unsigned int __ATTRS_o_ai
5932 vec_vminuw(vector unsigned int __a, vector bool int __b) {
5933  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5934 }
5935 
5936 /* vec_vminfp */
5937 
5938 static __inline__ vector float __attribute__((__always_inline__))
5939 vec_vminfp(vector float __a, vector float __b) {
5940 #ifdef __VSX__
5941  return __builtin_vsx_xvminsp(__a, __b);
5942 #else
5943  return __builtin_altivec_vminfp(__a, __b);
5944 #endif
5945 }
5946 
5947 /* vec_mladd */
5948 
5949 #define __builtin_altivec_vmladduhm vec_mladd
5950 
5951 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
5952  vector short __b,
5953  vector short __c) {
5954  return __a * __b + __c;
5955 }
5956 
5957 static __inline__ vector short __ATTRS_o_ai vec_mladd(
5958  vector short __a, vector unsigned short __b, vector unsigned short __c) {
5959  return __a * (vector short)__b + (vector short)__c;
5960 }
5961 
5962 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
5963  vector short __b,
5964  vector short __c) {
5965  return (vector short)__a * __b + __c;
5966 }
5967 
5968 static __inline__ vector unsigned short __ATTRS_o_ai
5969 vec_mladd(vector unsigned short __a, vector unsigned short __b,
5970  vector unsigned short __c) {
5971  return __a * __b + __c;
5972 }
5973 
5974 /* vec_vmladduhm */
5975 
5976 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
5977  vector short __b,
5978  vector short __c) {
5979  return __a * __b + __c;
5980 }
5981 
5982 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
5983  vector short __a, vector unsigned short __b, vector unsigned short __c) {
5984  return __a * (vector short)__b + (vector short)__c;
5985 }
5986 
5987 static __inline__ vector short __ATTRS_o_ai
5988 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
5989  return (vector short)__a * __b + __c;
5990 }
5991 
5992 static __inline__ vector unsigned short __ATTRS_o_ai
5993 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
5994  vector unsigned short __c) {
5995  return __a * __b + __c;
5996 }
5997 
5998 /* vec_mradds */
5999 
6000 static __inline__ vector short __attribute__((__always_inline__))
6001 vec_mradds(vector short __a, vector short __b, vector short __c) {
6002  return __builtin_altivec_vmhraddshs(__a, __b, __c);
6003 }
6004 
6005 /* vec_vmhraddshs */
6006 
6007 static __inline__ vector short __attribute__((__always_inline__))
6008 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
6009  return __builtin_altivec_vmhraddshs(__a, __b, __c);
6010 }
6011 
6012 /* vec_msum */
6013 
6014 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
6015  vector unsigned char __b,
6016  vector int __c) {
6017  return __builtin_altivec_vmsummbm(__a, __b, __c);
6018 }
6019 
6020 static __inline__ vector unsigned int __ATTRS_o_ai
6021 vec_msum(vector unsigned char __a, vector unsigned char __b,
6022  vector unsigned int __c) {
6023  return __builtin_altivec_vmsumubm(__a, __b, __c);
6024 }
6025 
6026 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
6027  vector short __b,
6028  vector int __c) {
6029  return __builtin_altivec_vmsumshm(__a, __b, __c);
6030 }
6031 
6032 static __inline__ vector unsigned int __ATTRS_o_ai
6033 vec_msum(vector unsigned short __a, vector unsigned short __b,
6034  vector unsigned int __c) {
6035  return __builtin_altivec_vmsumuhm(__a, __b, __c);
6036 }
6037 
6038 /* vec_msumc */
6039 
6040 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6041 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6042 vec_msumc(vector unsigned long long __a, vector unsigned long long __b,
6043  vector unsigned __int128 __c) {
6044  return __builtin_altivec_vmsumcud(__a, __b, __c);
6045 }
6046 #endif
6047 
6048 /* vec_vmsummbm */
6049 
6050 static __inline__ vector int __attribute__((__always_inline__))
6051 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
6052  return __builtin_altivec_vmsummbm(__a, __b, __c);
6053 }
6054 
6055 /* vec_vmsumubm */
6056 
6057 static __inline__ vector unsigned int __attribute__((__always_inline__))
6058 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
6059  vector unsigned int __c) {
6060  return __builtin_altivec_vmsumubm(__a, __b, __c);
6061 }
6062 
6063 /* vec_vmsumshm */
6064 
6065 static __inline__ vector int __attribute__((__always_inline__))
6066 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
6067  return __builtin_altivec_vmsumshm(__a, __b, __c);
6068 }
6069 
6070 /* vec_vmsumuhm */
6071 
6072 static __inline__ vector unsigned int __attribute__((__always_inline__))
6073 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
6074  vector unsigned int __c) {
6075  return __builtin_altivec_vmsumuhm(__a, __b, __c);
6076 }
6077 
6078 /* vec_msums */
6079 
6080 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
6081  vector short __b,
6082  vector int __c) {
6083  return __builtin_altivec_vmsumshs(__a, __b, __c);
6084 }
6085 
6086 static __inline__ vector unsigned int __ATTRS_o_ai
6087 vec_msums(vector unsigned short __a, vector unsigned short __b,
6088  vector unsigned int __c) {
6089  return __builtin_altivec_vmsumuhs(__a, __b, __c);
6090 }
6091 
6092 /* vec_vmsumshs */
6093 
6094 static __inline__ vector int __attribute__((__always_inline__))
6095 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
6096  return __builtin_altivec_vmsumshs(__a, __b, __c);
6097 }
6098 
6099 /* vec_vmsumuhs */
6100 
6101 static __inline__ vector unsigned int __attribute__((__always_inline__))
6102 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
6103  vector unsigned int __c) {
6104  return __builtin_altivec_vmsumuhs(__a, __b, __c);
6105 }
6106 
6107 /* vec_mtvscr */
6108 
6109 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
6110  __builtin_altivec_mtvscr((vector int)__a);
6111 }
6112 
6113 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
6114  __builtin_altivec_mtvscr((vector int)__a);
6115 }
6116 
6117 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
6118  __builtin_altivec_mtvscr((vector int)__a);
6119 }
6120 
6121 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
6122  __builtin_altivec_mtvscr((vector int)__a);
6123 }
6124 
6125 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
6126  __builtin_altivec_mtvscr((vector int)__a);
6127 }
6128 
6129 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
6130  __builtin_altivec_mtvscr((vector int)__a);
6131 }
6132 
6133 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
6134  __builtin_altivec_mtvscr((vector int)__a);
6135 }
6136 
6137 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
6138  __builtin_altivec_mtvscr((vector int)__a);
6139 }
6140 
6141 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
6142  __builtin_altivec_mtvscr((vector int)__a);
6143 }
6144 
6145 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
6146  __builtin_altivec_mtvscr((vector int)__a);
6147 }
6148 
6149 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
6150  __builtin_altivec_mtvscr((vector int)__a);
6151 }
6152 
6153 /* vec_mul */
6154 
6155 /* Integer vector multiplication will involve multiplication of the odd/even
6156  elements separately, then truncating the results and moving to the
6157  result vector.
6158 */
6159 static __inline__ vector signed char __ATTRS_o_ai
6160 vec_mul(vector signed char __a, vector signed char __b) {
6161  return __a * __b;
6162 }
6163 
6164 static __inline__ vector unsigned char __ATTRS_o_ai
6165 vec_mul(vector unsigned char __a, vector unsigned char __b) {
6166  return __a * __b;
6167 }
6168 
6169 static __inline__ vector signed short __ATTRS_o_ai
6170 vec_mul(vector signed short __a, vector signed short __b) {
6171  return __a * __b;
6172 }
6173 
6174 static __inline__ vector unsigned short __ATTRS_o_ai
6175 vec_mul(vector unsigned short __a, vector unsigned short __b) {
6176  return __a * __b;
6177 }
6178 
6179 static __inline__ vector signed int __ATTRS_o_ai
6180 vec_mul(vector signed int __a, vector signed int __b) {
6181  return __a * __b;
6182 }
6183 
6184 static __inline__ vector unsigned int __ATTRS_o_ai
6185 vec_mul(vector unsigned int __a, vector unsigned int __b) {
6186  return __a * __b;
6187 }
6188 
6189 #ifdef __VSX__
6190 static __inline__ vector signed long long __ATTRS_o_ai
6191 vec_mul(vector signed long long __a, vector signed long long __b) {
6192  return __a * __b;
6193 }
6194 
6195 static __inline__ vector unsigned long long __ATTRS_o_ai
6196 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
6197  return __a * __b;
6198 }
6199 #endif
6200 
6201 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
6202  vector float __b) {
6203  return __a * __b;
6204 }
6205 
6206 #ifdef __VSX__
6207 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
6208  vector double __b) {
6209  return __a * __b;
6210 }
6211 #endif
6212 
6213 /* The vmulos* and vmules* instructions have a big endian bias, so
6214  we must reverse the meaning of "even" and "odd" for little endian. */
6215 
6216 /* vec_mule */
6217 
6218 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
6219  vector signed char __b) {
6220 #ifdef __LITTLE_ENDIAN__
6221  return __builtin_altivec_vmulosb(__a, __b);
6222 #else
6223  return __builtin_altivec_vmulesb(__a, __b);
6224 #endif
6225 }
6226 
6227 static __inline__ vector unsigned short __ATTRS_o_ai
6228 vec_mule(vector unsigned char __a, vector unsigned char __b) {
6229 #ifdef __LITTLE_ENDIAN__
6230  return __builtin_altivec_vmuloub(__a, __b);
6231 #else
6232  return __builtin_altivec_vmuleub(__a, __b);
6233 #endif
6234 }
6235 
6236 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
6237  vector short __b) {
6238 #ifdef __LITTLE_ENDIAN__
6239  return __builtin_altivec_vmulosh(__a, __b);
6240 #else
6241  return __builtin_altivec_vmulesh(__a, __b);
6242 #endif
6243 }
6244 
6245 static __inline__ vector unsigned int __ATTRS_o_ai
6246 vec_mule(vector unsigned short __a, vector unsigned short __b) {
6247 #ifdef __LITTLE_ENDIAN__
6248  return __builtin_altivec_vmulouh(__a, __b);
6249 #else
6250  return __builtin_altivec_vmuleuh(__a, __b);
6251 #endif
6252 }
6253 
6254 #ifdef __POWER8_VECTOR__
6255 static __inline__ vector signed long long __ATTRS_o_ai
6256 vec_mule(vector signed int __a, vector signed int __b) {
6257 #ifdef __LITTLE_ENDIAN__
6258  return __builtin_altivec_vmulosw(__a, __b);
6259 #else
6260  return __builtin_altivec_vmulesw(__a, __b);
6261 #endif
6262 }
6263 
6264 static __inline__ vector unsigned long long __ATTRS_o_ai
6265 vec_mule(vector unsigned int __a, vector unsigned int __b) {
6266 #ifdef __LITTLE_ENDIAN__
6267  return __builtin_altivec_vmulouw(__a, __b);
6268 #else
6269  return __builtin_altivec_vmuleuw(__a, __b);
6270 #endif
6271 }
6272 #endif
6273 
6274 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6275 static __inline__ vector signed __int128 __ATTRS_o_ai
6276 vec_mule(vector signed long long __a, vector signed long long __b) {
6277 #ifdef __LITTLE_ENDIAN__
6278  return __builtin_altivec_vmulosd(__a, __b);
6279 #else
6280  return __builtin_altivec_vmulesd(__a, __b);
6281 #endif
6282 }
6283 
6284 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6285 vec_mule(vector unsigned long long __a, vector unsigned long long __b) {
6286 #ifdef __LITTLE_ENDIAN__
6287  return __builtin_altivec_vmuloud(__a, __b);
6288 #else
6289  return __builtin_altivec_vmuleud(__a, __b);
6290 #endif
6291 }
6292 #endif
6293 
6294 /* vec_vmulesb */
6295 
6296 static __inline__ vector short __attribute__((__always_inline__))
6297 vec_vmulesb(vector signed char __a, vector signed char __b) {
6298 #ifdef __LITTLE_ENDIAN__
6299  return __builtin_altivec_vmulosb(__a, __b);
6300 #else
6301  return __builtin_altivec_vmulesb(__a, __b);
6302 #endif
6303 }
6304 
6305 /* vec_vmuleub */
6306 
6307 static __inline__ vector unsigned short __attribute__((__always_inline__))
6308 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
6309 #ifdef __LITTLE_ENDIAN__
6310  return __builtin_altivec_vmuloub(__a, __b);
6311 #else
6312  return __builtin_altivec_vmuleub(__a, __b);
6313 #endif
6314 }
6315 
6316 /* vec_vmulesh */
6317 
6318 static __inline__ vector int __attribute__((__always_inline__))
6319 vec_vmulesh(vector short __a, vector short __b) {
6320 #ifdef __LITTLE_ENDIAN__
6321  return __builtin_altivec_vmulosh(__a, __b);
6322 #else
6323  return __builtin_altivec_vmulesh(__a, __b);
6324 #endif
6325 }
6326 
6327 /* vec_vmuleuh */
6328 
6329 static __inline__ vector unsigned int __attribute__((__always_inline__))
6330 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
6331 #ifdef __LITTLE_ENDIAN__
6332  return __builtin_altivec_vmulouh(__a, __b);
6333 #else
6334  return __builtin_altivec_vmuleuh(__a, __b);
6335 #endif
6336 }
6337 
6338 /* vec_mulh */
6339 
6340 #ifdef __POWER10_VECTOR__
6341 static __inline__ vector signed int __ATTRS_o_ai
6342 vec_mulh(vector signed int __a, vector signed int __b) {
6343  return __builtin_altivec_vmulhsw(__a, __b);
6344 }
6345 
6346 static __inline__ vector unsigned int __ATTRS_o_ai
6347 vec_mulh(vector unsigned int __a, vector unsigned int __b) {
6348  return __builtin_altivec_vmulhuw(__a, __b);
6349 }
6350 
6351 static __inline__ vector signed long long __ATTRS_o_ai
6352 vec_mulh(vector signed long long __a, vector signed long long __b) {
6353  return __builtin_altivec_vmulhsd(__a, __b);
6354 }
6355 
6356 static __inline__ vector unsigned long long __ATTRS_o_ai
6357 vec_mulh(vector unsigned long long __a, vector unsigned long long __b) {
6358  return __builtin_altivec_vmulhud(__a, __b);
6359 }
6360 #endif
6361 
6362 /* vec_mulo */
6363 
6364 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
6365  vector signed char __b) {
6366 #ifdef __LITTLE_ENDIAN__
6367  return __builtin_altivec_vmulesb(__a, __b);
6368 #else
6369  return __builtin_altivec_vmulosb(__a, __b);
6370 #endif
6371 }
6372 
6373 static __inline__ vector unsigned short __ATTRS_o_ai
6374 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
6375 #ifdef __LITTLE_ENDIAN__
6376  return __builtin_altivec_vmuleub(__a, __b);
6377 #else
6378  return __builtin_altivec_vmuloub(__a, __b);
6379 #endif
6380 }
6381 
6382 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
6383  vector short __b) {
6384 #ifdef __LITTLE_ENDIAN__
6385  return __builtin_altivec_vmulesh(__a, __b);
6386 #else
6387  return __builtin_altivec_vmulosh(__a, __b);
6388 #endif
6389 }
6390 
6391 static __inline__ vector unsigned int __ATTRS_o_ai
6392 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
6393 #ifdef __LITTLE_ENDIAN__
6394  return __builtin_altivec_vmuleuh(__a, __b);
6395 #else
6396  return __builtin_altivec_vmulouh(__a, __b);
6397 #endif
6398 }
6399 
6400 #ifdef __POWER8_VECTOR__
6401 static __inline__ vector signed long long __ATTRS_o_ai
6402 vec_mulo(vector signed int __a, vector signed int __b) {
6403 #ifdef __LITTLE_ENDIAN__
6404  return __builtin_altivec_vmulesw(__a, __b);
6405 #else
6406  return __builtin_altivec_vmulosw(__a, __b);
6407 #endif
6408 }
6409 
6410 static __inline__ vector unsigned long long __ATTRS_o_ai
6411 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
6412 #ifdef __LITTLE_ENDIAN__
6413  return __builtin_altivec_vmuleuw(__a, __b);
6414 #else
6415  return __builtin_altivec_vmulouw(__a, __b);
6416 #endif
6417 }
6418 #endif
6419 
6420 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6421 static __inline__ vector signed __int128 __ATTRS_o_ai
6422 vec_mulo(vector signed long long __a, vector signed long long __b) {
6423 #ifdef __LITTLE_ENDIAN__
6424  return __builtin_altivec_vmulesd(__a, __b);
6425 #else
6426  return __builtin_altivec_vmulosd(__a, __b);
6427 #endif
6428 }
6429 
6430 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6431 vec_mulo(vector unsigned long long __a, vector unsigned long long __b) {
6432 #ifdef __LITTLE_ENDIAN__
6433  return __builtin_altivec_vmuleud(__a, __b);
6434 #else
6435  return __builtin_altivec_vmuloud(__a, __b);
6436 #endif
6437 }
6438 #endif
6439 
6440 /* vec_vmulosb */
6441 
6442 static __inline__ vector short __attribute__((__always_inline__))
6443 vec_vmulosb(vector signed char __a, vector signed char __b) {
6444 #ifdef __LITTLE_ENDIAN__
6445  return __builtin_altivec_vmulesb(__a, __b);
6446 #else
6447  return __builtin_altivec_vmulosb(__a, __b);
6448 #endif
6449 }
6450 
6451 /* vec_vmuloub */
6452 
6453 static __inline__ vector unsigned short __attribute__((__always_inline__))
6454 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
6455 #ifdef __LITTLE_ENDIAN__
6456  return __builtin_altivec_vmuleub(__a, __b);
6457 #else
6458  return __builtin_altivec_vmuloub(__a, __b);
6459 #endif
6460 }
6461 
6462 /* vec_vmulosh */
6463 
6464 static __inline__ vector int __attribute__((__always_inline__))
6465 vec_vmulosh(vector short __a, vector short __b) {
6466 #ifdef __LITTLE_ENDIAN__
6467  return __builtin_altivec_vmulesh(__a, __b);
6468 #else
6469  return __builtin_altivec_vmulosh(__a, __b);
6470 #endif
6471 }
6472 
6473 /* vec_vmulouh */
6474 
6475 static __inline__ vector unsigned int __attribute__((__always_inline__))
6476 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
6477 #ifdef __LITTLE_ENDIAN__
6478  return __builtin_altivec_vmuleuh(__a, __b);
6479 #else
6480  return __builtin_altivec_vmulouh(__a, __b);
6481 #endif
6482 }
6483 
6484 /* vec_nand */
6485 
6486 #ifdef __POWER8_VECTOR__
6487 static __inline__ vector signed char __ATTRS_o_ai
6488 vec_nand(vector signed char __a, vector signed char __b) {
6489  return ~(__a & __b);
6490 }
6491 
6492 static __inline__ vector signed char __ATTRS_o_ai
6493 vec_nand(vector signed char __a, vector bool char __b) {
6494  return ~(__a & __b);
6495 }
6496 
6497 static __inline__ vector signed char __ATTRS_o_ai
6498 vec_nand(vector bool char __a, vector signed char __b) {
6499  return ~(__a & __b);
6500 }
6501 
6502 static __inline__ vector unsigned char __ATTRS_o_ai
6503 vec_nand(vector unsigned char __a, vector unsigned char __b) {
6504  return ~(__a & __b);
6505 }
6506 
6507 static __inline__ vector unsigned char __ATTRS_o_ai
6508 vec_nand(vector unsigned char __a, vector bool char __b) {
6509  return ~(__a & __b);
6510 }
6511 
6512 static __inline__ vector unsigned char __ATTRS_o_ai
6513 vec_nand(vector bool char __a, vector unsigned char __b) {
6514  return ~(__a & __b);
6515 }
6516 
6517 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
6518  vector bool char __b) {
6519  return ~(__a & __b);
6520 }
6521 
6522 static __inline__ vector signed short __ATTRS_o_ai
6523 vec_nand(vector signed short __a, vector signed short __b) {
6524  return ~(__a & __b);
6525 }
6526 
6527 static __inline__ vector signed short __ATTRS_o_ai
6528 vec_nand(vector signed short __a, vector bool short __b) {
6529  return ~(__a & __b);
6530 }
6531 
6532 static __inline__ vector signed short __ATTRS_o_ai
6533 vec_nand(vector bool short __a, vector signed short __b) {
6534  return ~(__a & __b);
6535 }
6536 
6537 static __inline__ vector unsigned short __ATTRS_o_ai
6538 vec_nand(vector unsigned short __a, vector unsigned short __b) {
6539  return ~(__a & __b);
6540 }
6541 
6542 static __inline__ vector unsigned short __ATTRS_o_ai
6543 vec_nand(vector unsigned short __a, vector bool short __b) {
6544  return ~(__a & __b);
6545 }
6546 
6547 static __inline__ vector bool short __ATTRS_o_ai
6548 vec_nand(vector bool short __a, vector bool short __b) {
6549  return ~(__a & __b);
6550 }
6551 
6552 static __inline__ vector signed int __ATTRS_o_ai
6553 vec_nand(vector signed int __a, vector signed int __b) {
6554  return ~(__a & __b);
6555 }
6556 
6557 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
6558  vector bool int __b) {
6559  return ~(__a & __b);
6560 }
6561 
6562 static __inline__ vector signed int __ATTRS_o_ai
6563 vec_nand(vector bool int __a, vector signed int __b) {
6564  return ~(__a & __b);
6565 }
6566 
6567 static __inline__ vector unsigned int __ATTRS_o_ai
6568 vec_nand(vector unsigned int __a, vector unsigned int __b) {
6569  return ~(__a & __b);
6570 }
6571 
6572 static __inline__ vector unsigned int __ATTRS_o_ai
6573 vec_nand(vector unsigned int __a, vector bool int __b) {
6574  return ~(__a & __b);
6575 }
6576 
6577 static __inline__ vector unsigned int __ATTRS_o_ai
6578 vec_nand(vector bool int __a, vector unsigned int __b) {
6579  return ~(__a & __b);
6580 }
6581 
6582 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
6583  vector bool int __b) {
6584  return ~(__a & __b);
6585 }
6586 
6587 static __inline__ vector float __ATTRS_o_ai
6588 vec_nand(vector float __a, vector float __b) {
6589  return (vector float)(~((vector unsigned int)__a &
6590  (vector unsigned int)__b));
6591 }
6592 
6593 static __inline__ vector signed long long __ATTRS_o_ai
6594 vec_nand(vector signed long long __a, vector signed long long __b) {
6595  return ~(__a & __b);
6596 }
6597 
6598 static __inline__ vector signed long long __ATTRS_o_ai
6599 vec_nand(vector signed long long __a, vector bool long long __b) {
6600  return ~(__a & __b);
6601 }
6602 
6603 static __inline__ vector signed long long __ATTRS_o_ai
6604 vec_nand(vector bool long long __a, vector signed long long __b) {
6605  return ~(__a & __b);
6606 }
6607 
6608 static __inline__ vector unsigned long long __ATTRS_o_ai
6609 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
6610  return ~(__a & __b);
6611 }
6612 
6613 static __inline__ vector unsigned long long __ATTRS_o_ai
6614 vec_nand(vector unsigned long long __a, vector bool long long __b) {
6615  return ~(__a & __b);
6616 }
6617 
6618 static __inline__ vector unsigned long long __ATTRS_o_ai
6619 vec_nand(vector bool long long __a, vector unsigned long long __b) {
6620  return ~(__a & __b);
6621 }
6622 
6623 static __inline__ vector bool long long __ATTRS_o_ai
6624 vec_nand(vector bool long long __a, vector bool long long __b) {
6625  return ~(__a & __b);
6626 }
6627 
6628 static __inline__ vector double __ATTRS_o_ai
6629 vec_nand(vector double __a, vector double __b) {
6630  return (vector double)(~((vector unsigned long long)__a &
6631  (vector unsigned long long)__b));
6632 }
6633 
6634 #endif
6635 
6636 /* vec_nmadd */
6637 
6638 #ifdef __VSX__
6639 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
6640  vector float __b,
6641  vector float __c) {
6642  return __builtin_vsx_xvnmaddasp(__a, __b, __c);
6643 }
6644 
6645 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
6646  vector double __b,
6647  vector double __c) {
6648  return __builtin_vsx_xvnmaddadp(__a, __b, __c);
6649 }
6650 #endif
6651 
6652 /* vec_nmsub */
6653 
6654 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
6655  vector float __b,
6656  vector float __c) {
6657 #ifdef __VSX__
6658  return __builtin_vsx_xvnmsubasp(__a, __b, __c);
6659 #else
6660  return __builtin_altivec_vnmsubfp(__a, __b, __c);
6661 #endif
6662 }
6663 
6664 #ifdef __VSX__
6665 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
6666  vector double __b,
6667  vector double __c) {
6668  return __builtin_vsx_xvnmsubadp(__a, __b, __c);
6669 }
6670 #endif
6671 
6672 /* vec_vnmsubfp */
6673 
6674 static __inline__ vector float __attribute__((__always_inline__))
6675 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
6676  return __builtin_altivec_vnmsubfp(__a, __b, __c);
6677 }
6678 
6679 /* vec_nor */
6680 
6681 #define __builtin_altivec_vnor vec_nor
6682 
6683 static __inline__ vector signed char __ATTRS_o_ai
6684 vec_nor(vector signed char __a, vector signed char __b) {
6685  return ~(__a | __b);
6686 }
6687 
6688 static __inline__ vector unsigned char __ATTRS_o_ai
6689 vec_nor(vector unsigned char __a, vector unsigned char __b) {
6690  return ~(__a | __b);
6691 }
6692 
6693 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
6694  vector bool char __b) {
6695  return ~(__a | __b);
6696 }
6697 
6698 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
6699  vector short __b) {
6700  return ~(__a | __b);
6701 }
6702 
6703 static __inline__ vector unsigned short __ATTRS_o_ai
6704 vec_nor(vector unsigned short __a, vector unsigned short __b) {
6705  return ~(__a | __b);
6706 }
6707 
6708 static __inline__ vector bool short __ATTRS_o_ai
6709 vec_nor(vector bool short __a, vector bool short __b) {
6710  return ~(__a | __b);
6711 }
6712 
6713 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
6714  vector int __b) {
6715  return ~(__a | __b);
6716 }
6717 
6718 static __inline__ vector unsigned int __ATTRS_o_ai
6719 vec_nor(vector unsigned int __a, vector unsigned int __b) {
6720  return ~(__a | __b);
6721 }
6722 
6723 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
6724  vector bool int __b) {
6725  return ~(__a | __b);
6726 }
6727 
6728 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
6729  vector float __b) {
6730  vector unsigned int __res =
6731  ~((vector unsigned int)__a | (vector unsigned int)__b);
6732  return (vector float)__res;
6733 }
6734 
6735 #ifdef __VSX__
6736 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
6737  vector double __b) {
6738  vector unsigned long long __res =
6739  ~((vector unsigned long long)__a | (vector unsigned long long)__b);
6740  return (vector double)__res;
6741 }
6742 #endif
6743 
6744 /* vec_vnor */
6745 
6746 static __inline__ vector signed char __ATTRS_o_ai
6747 vec_vnor(vector signed char __a, vector signed char __b) {
6748  return ~(__a | __b);
6749 }
6750 
6751 static __inline__ vector unsigned char __ATTRS_o_ai
6752 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
6753  return ~(__a | __b);
6754 }
6755 
6756 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
6757  vector bool char __b) {
6758  return ~(__a | __b);
6759 }
6760 
6761 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
6762  vector short __b) {
6763  return ~(__a | __b);
6764 }
6765 
6766 static __inline__ vector unsigned short __ATTRS_o_ai
6767 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
6768  return ~(__a | __b);
6769 }
6770 
6771 static __inline__ vector bool short __ATTRS_o_ai
6772 vec_vnor(vector bool short __a, vector bool short __b) {
6773  return ~(__a | __b);
6774 }
6775 
6776 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
6777  vector int __b) {
6778  return ~(__a | __b);
6779 }
6780 
6781 static __inline__ vector unsigned int __ATTRS_o_ai
6782 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
6783  return ~(__a | __b);
6784 }
6785 
6786 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
6787  vector bool int __b) {
6788  return ~(__a | __b);
6789 }
6790 
6791 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
6792  vector float __b) {
6793  vector unsigned int __res =
6794  ~((vector unsigned int)__a | (vector unsigned int)__b);
6795  return (vector float)__res;
6796 }
6797 
6798 #ifdef __VSX__
6799 static __inline__ vector signed long long __ATTRS_o_ai
6800 vec_nor(vector signed long long __a, vector signed long long __b) {
6801  return ~(__a | __b);
6802 }
6803 
6804 static __inline__ vector unsigned long long __ATTRS_o_ai
6805 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
6806  return ~(__a | __b);
6807 }
6808 
6809 static __inline__ vector bool long long __ATTRS_o_ai
6810 vec_nor(vector bool long long __a, vector bool long long __b) {
6811  return ~(__a | __b);
6812 }
6813 #endif
6814 
6815 /* vec_or */
6816 
6817 #define __builtin_altivec_vor vec_or
6818 
6819 static __inline__ vector signed char __ATTRS_o_ai
6820 vec_or(vector signed char __a, vector signed char __b) {
6821  return __a | __b;
6822 }
6823 
6824 static __inline__ vector signed char __ATTRS_o_ai
6825 vec_or(vector bool char __a, vector signed char __b) {
6826  return (vector signed char)__a | __b;
6827 }
6828 
6829 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
6830  vector bool char __b) {
6831  return __a | (vector signed char)__b;
6832 }
6833 
6834 static __inline__ vector unsigned char __ATTRS_o_ai
6835 vec_or(vector unsigned char __a, vector unsigned char __b) {
6836  return __a | __b;
6837 }
6838 
6839 static __inline__ vector unsigned char __ATTRS_o_ai
6840 vec_or(vector bool char __a, vector unsigned char __b) {
6841  return (vector unsigned char)__a | __b;
6842 }
6843 
6844 static __inline__ vector unsigned char __ATTRS_o_ai
6845 vec_or(vector unsigned char __a, vector bool char __b) {
6846  return __a | (vector unsigned char)__b;
6847 }
6848 
6849 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
6850  vector bool char __b) {
6851  return __a | __b;
6852 }
6853 
6854 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6855  vector short __b) {
6856  return __a | __b;
6857 }
6858 
6859 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
6860  vector short __b) {
6861  return (vector short)__a | __b;
6862 }
6863 
6864 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6865  vector bool short __b) {
6866  return __a | (vector short)__b;
6867 }
6868 
6869 static __inline__ vector unsigned short __ATTRS_o_ai
6870 vec_or(vector unsigned short __a, vector unsigned short __b) {
6871  return __a | __b;
6872 }
6873 
6874 static __inline__ vector unsigned short __ATTRS_o_ai
6875 vec_or(vector bool short __a, vector unsigned short __b) {
6876  return (vector unsigned short)__a | __b;
6877 }
6878 
6879 static __inline__ vector unsigned short __ATTRS_o_ai
6880 vec_or(vector unsigned short __a, vector bool short __b) {
6881  return __a | (vector unsigned short)__b;
6882 }
6883 
6884 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
6885  vector bool short __b) {
6886  return __a | __b;
6887 }
6888 
6889 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6890  vector int __b) {
6891  return __a | __b;
6892 }
6893 
6894 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
6895  vector int __b) {
6896  return (vector int)__a | __b;
6897 }
6898 
6899 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6900  vector bool int __b) {
6901  return __a | (vector int)__b;
6902 }
6903 
6904 static __inline__ vector unsigned int __ATTRS_o_ai
6905 vec_or(vector unsigned int __a, vector unsigned int __b) {
6906  return __a | __b;
6907 }
6908 
6909 static __inline__ vector unsigned int __ATTRS_o_ai
6910 vec_or(vector bool int __a, vector unsigned int __b) {
6911  return (vector unsigned int)__a | __b;
6912 }
6913 
6914 static __inline__ vector unsigned int __ATTRS_o_ai
6915 vec_or(vector unsigned int __a, vector bool int __b) {
6916  return __a | (vector unsigned int)__b;
6917 }
6918 
6919 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
6920  vector bool int __b) {
6921  return __a | __b;
6922 }
6923 
6924 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6925  vector float __b) {
6926  vector unsigned int __res =
6927  (vector unsigned int)__a | (vector unsigned int)__b;
6928  return (vector float)__res;
6929 }
6930 
6931 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
6932  vector float __b) {
6933  vector unsigned int __res =
6934  (vector unsigned int)__a | (vector unsigned int)__b;
6935  return (vector float)__res;
6936 }
6937 
6938 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6939  vector bool int __b) {
6940  vector unsigned int __res =
6941  (vector unsigned int)__a | (vector unsigned int)__b;
6942  return (vector float)__res;
6943 }
6944 
6945 #ifdef __VSX__
6946 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
6947  vector double __b) {
6948  return (vector double)((vector unsigned long long)__a |
6949  (vector unsigned long long)__b);
6950 }
6951 
6952 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6953  vector bool long long __b) {
6954  return (vector double)((vector unsigned long long)__a |
6955  (vector unsigned long long)__b);
6956 }
6957 
6958 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6959  vector double __b) {
6960  return (vector double)((vector unsigned long long)__a |
6961  (vector unsigned long long)__b);
6962 }
6963 
6964 static __inline__ vector signed long long __ATTRS_o_ai
6965 vec_or(vector signed long long __a, vector signed long long __b) {
6966  return __a | __b;
6967 }
6968 
6969 static __inline__ vector signed long long __ATTRS_o_ai
6970 vec_or(vector bool long long __a, vector signed long long __b) {
6971  return (vector signed long long)__a | __b;
6972 }
6973 
6974 static __inline__ vector signed long long __ATTRS_o_ai
6975 vec_or(vector signed long long __a, vector bool long long __b) {
6976  return __a | (vector signed long long)__b;
6977 }
6978 
6979 static __inline__ vector unsigned long long __ATTRS_o_ai
6980 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
6981  return __a | __b;
6982 }
6983 
6984 static __inline__ vector unsigned long long __ATTRS_o_ai
6985 vec_or(vector bool long long __a, vector unsigned long long __b) {
6986  return (vector unsigned long long)__a | __b;
6987 }
6988 
6989 static __inline__ vector unsigned long long __ATTRS_o_ai
6990 vec_or(vector unsigned long long __a, vector bool long long __b) {
6991  return __a | (vector unsigned long long)__b;
6992 }
6993 
6994 static __inline__ vector bool long long __ATTRS_o_ai
6995 vec_or(vector bool long long __a, vector bool long long __b) {
6996  return __a | __b;
6997 }
6998 #endif
6999 
7000 #ifdef __POWER8_VECTOR__
7001 static __inline__ vector signed char __ATTRS_o_ai
7002 vec_orc(vector signed char __a, vector signed char __b) {
7003  return __a | ~__b;
7004 }
7005 
7006 static __inline__ vector signed char __ATTRS_o_ai
7007 vec_orc(vector signed char __a, vector bool char __b) {
7008  return __a | ~__b;
7009 }
7010 
7011 static __inline__ vector signed char __ATTRS_o_ai
7012 vec_orc(vector bool char __a, vector signed char __b) {
7013  return __a | ~__b;
7014 }
7015 
7016 static __inline__ vector unsigned char __ATTRS_o_ai
7017 vec_orc(vector unsigned char __a, vector unsigned char __b) {
7018  return __a | ~__b;
7019 }
7020 
7021 static __inline__ vector unsigned char __ATTRS_o_ai
7022 vec_orc(vector unsigned char __a, vector bool char __b) {
7023  return __a | ~__b;
7024 }
7025 
7026 static __inline__ vector unsigned char __ATTRS_o_ai
7027 vec_orc(vector bool char __a, vector unsigned char __b) {
7028  return __a | ~__b;
7029 }
7030 
7031 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
7032  vector bool char __b) {
7033  return __a | ~__b;
7034 }
7035 
7036 static __inline__ vector signed short __ATTRS_o_ai
7037 vec_orc(vector signed short __a, vector signed short __b) {
7038  return __a | ~__b;
7039 }
7040 
7041 static __inline__ vector signed short __ATTRS_o_ai
7042 vec_orc(vector signed short __a, vector bool short __b) {
7043  return __a | ~__b;
7044 }
7045 
7046 static __inline__ vector signed short __ATTRS_o_ai
7047 vec_orc(vector bool short __a, vector signed short __b) {
7048  return __a | ~__b;
7049 }
7050 
7051 static __inline__ vector unsigned short __ATTRS_o_ai
7052 vec_orc(vector unsigned short __a, vector unsigned short __b) {
7053  return __a | ~__b;
7054 }
7055 
7056 static __inline__ vector unsigned short __ATTRS_o_ai
7057 vec_orc(vector unsigned short __a, vector bool short __b) {
7058  return __a | ~__b;
7059 }
7060 
7061 static __inline__ vector unsigned short __ATTRS_o_ai
7062 vec_orc(vector bool short __a, vector unsigned short __b) {
7063  return __a | ~__b;
7064 }
7065 
7066 static __inline__ vector bool short __ATTRS_o_ai
7067 vec_orc(vector bool short __a, vector bool short __b) {
7068  return __a | ~__b;
7069 }
7070 
7071 static __inline__ vector signed int __ATTRS_o_ai
7072 vec_orc(vector signed int __a, vector signed int __b) {
7073  return __a | ~__b;
7074 }
7075 
7076 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
7077  vector bool int __b) {
7078  return __a | ~__b;
7079 }
7080 
7081 static __inline__ vector signed int __ATTRS_o_ai
7082 vec_orc(vector bool int __a, vector signed int __b) {
7083  return __a | ~__b;
7084 }
7085 
7086 static __inline__ vector unsigned int __ATTRS_o_ai
7087 vec_orc(vector unsigned int __a, vector unsigned int __b) {
7088  return __a | ~__b;
7089 }
7090 
7091 static __inline__ vector unsigned int __ATTRS_o_ai
7092 vec_orc(vector unsigned int __a, vector bool int __b) {
7093  return __a | ~__b;
7094 }
7095 
7096 static __inline__ vector unsigned int __ATTRS_o_ai
7097 vec_orc(vector bool int __a, vector unsigned int __b) {
7098  return __a | ~__b;
7099 }
7100 
7101 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
7102  vector bool int __b) {
7103  return __a | ~__b;
7104 }
7105 
7106 static __inline__ vector float __ATTRS_o_ai
7107 vec_orc(vector bool int __a, vector float __b) {
7108  return (vector float)(__a | ~(vector unsigned int)__b);
7109 }
7110 
7111 static __inline__ vector float __ATTRS_o_ai
7112 vec_orc(vector float __a, vector bool int __b) {
7113  return (vector float)((vector unsigned int)__a | ~__b);
7114 }
7115 
7116 static __inline__ vector float __ATTRS_o_ai vec_orc(vector float __a,
7117  vector float __b) {
7118  return (vector float)((vector unsigned int)__a | ~(vector unsigned int)__b);
7119 }
7120 
7121 static __inline__ vector signed long long __ATTRS_o_ai
7122 vec_orc(vector signed long long __a, vector signed long long __b) {
7123  return __a | ~__b;
7124 }
7125 
7126 static __inline__ vector signed long long __ATTRS_o_ai
7127 vec_orc(vector signed long long __a, vector bool long long __b) {
7128  return __a | ~__b;
7129 }
7130 
7131 static __inline__ vector signed long long __ATTRS_o_ai
7132 vec_orc(vector bool long long __a, vector signed long long __b) {
7133  return __a | ~__b;
7134 }
7135 
7136 static __inline__ vector unsigned long long __ATTRS_o_ai
7137 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
7138  return __a | ~__b;
7139 }
7140 
7141 static __inline__ vector unsigned long long __ATTRS_o_ai
7142 vec_orc(vector unsigned long long __a, vector bool long long __b) {
7143  return __a | ~__b;
7144 }
7145 
7146 static __inline__ vector unsigned long long __ATTRS_o_ai
7147 vec_orc(vector bool long long __a, vector unsigned long long __b) {
7148  return __a | ~__b;
7149 }
7150 
7151 static __inline__ vector bool long long __ATTRS_o_ai
7152 vec_orc(vector bool long long __a, vector bool long long __b) {
7153  return __a | ~__b;
7154 }
7155 
7156 static __inline__ vector double __ATTRS_o_ai
7157 vec_orc(vector double __a, vector bool long long __b) {
7158  return (vector double)((vector unsigned long long)__a | ~__b);
7159 }
7160 
7161 static __inline__ vector double __ATTRS_o_ai
7162 vec_orc(vector bool long long __a, vector double __b) {
7163  return (vector double)(__a | ~(vector unsigned long long)__b);
7164 }
7165 
7166 static __inline__ vector double __ATTRS_o_ai vec_orc(vector double __a,
7167  vector double __b) {
7168  return (vector double)((vector bool long long)__a |
7169  ~(vector unsigned long long)__b);
7170 }
7171 #endif
7172 
7173 /* vec_vor */
7174 
7175 static __inline__ vector signed char __ATTRS_o_ai
7176 vec_vor(vector signed char __a, vector signed char __b) {
7177  return __a | __b;
7178 }
7179 
7180 static __inline__ vector signed char __ATTRS_o_ai
7181 vec_vor(vector bool char __a, vector signed char __b) {
7182  return (vector signed char)__a | __b;
7183 }
7184 
7185 static __inline__ vector signed char __ATTRS_o_ai
7186 vec_vor(vector signed char __a, vector bool char __b) {
7187  return __a | (vector signed char)__b;
7188 }
7189 
7190 static __inline__ vector unsigned char __ATTRS_o_ai
7191 vec_vor(vector unsigned char __a, vector unsigned char __b) {
7192  return __a | __b;
7193 }
7194 
7195 static __inline__ vector unsigned char __ATTRS_o_ai
7196 vec_vor(vector bool char __a, vector unsigned char __b) {
7197  return (vector unsigned char)__a | __b;
7198 }
7199 
7200 static __inline__ vector unsigned char __ATTRS_o_ai
7201 vec_vor(vector unsigned char __a, vector bool char __b) {
7202  return __a | (vector unsigned char)__b;
7203 }
7204 
7205 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
7206  vector bool char __b) {
7207  return __a | __b;
7208 }
7209 
7210 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
7211  vector short __b) {
7212  return __a | __b;
7213 }
7214 
7215 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
7216  vector short __b) {
7217  return (vector short)__a | __b;
7218 }
7219 
7220 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
7221  vector bool short __b) {
7222  return __a | (vector short)__b;
7223 }
7224 
7225 static __inline__ vector unsigned short __ATTRS_o_ai
7226 vec_vor(vector unsigned short __a, vector unsigned short __b) {
7227  return __a | __b;
7228 }
7229 
7230 static __inline__ vector unsigned short __ATTRS_o_ai
7231 vec_vor(vector bool short __a, vector unsigned short __b) {
7232  return (vector unsigned short)__a | __b;
7233 }
7234 
7235 static __inline__ vector unsigned short __ATTRS_o_ai
7236 vec_vor(vector unsigned short __a, vector bool short __b) {
7237  return __a | (vector unsigned short)__b;
7238 }
7239 
7240 static __inline__ vector bool short __ATTRS_o_ai
7241 vec_vor(vector bool short __a, vector bool short __b) {
7242  return __a | __b;
7243 }
7244 
7245 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
7246  vector int __b) {
7247  return __a | __b;
7248 }
7249 
7250 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
7251  vector int __b) {
7252  return (vector int)__a | __b;
7253 }
7254 
7255 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
7256  vector bool int __b) {
7257  return __a | (vector int)__b;
7258 }
7259 
7260 static __inline__ vector unsigned int __ATTRS_o_ai
7261 vec_vor(vector unsigned int __a, vector unsigned int __b) {
7262  return __a | __b;
7263 }
7264 
7265 static __inline__ vector unsigned int __ATTRS_o_ai
7266 vec_vor(vector bool int __a, vector unsigned int __b) {
7267  return (vector unsigned int)__a | __b;
7268 }
7269 
7270 static __inline__ vector unsigned int __ATTRS_o_ai
7271 vec_vor(vector unsigned int __a, vector bool int __b) {
7272  return __a | (vector unsigned int)__b;
7273 }
7274 
7275 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
7276  vector bool int __b) {
7277  return __a | __b;
7278 }
7279 
7280 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
7281  vector float __b) {
7282  vector unsigned int __res =
7283  (vector unsigned int)__a | (vector unsigned int)__b;
7284  return (vector float)__res;
7285 }
7286 
7287 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
7288  vector float __b) {
7289  vector unsigned int __res =
7290  (vector unsigned int)__a | (vector unsigned int)__b;
7291  return (vector float)__res;
7292 }
7293 
7294 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
7295  vector bool int __b) {
7296  vector unsigned int __res =
7297  (vector unsigned int)__a | (vector unsigned int)__b;
7298  return (vector float)__res;
7299 }
7300 
7301 #ifdef __VSX__
7302 static __inline__ vector signed long long __ATTRS_o_ai
7303 vec_vor(vector signed long long __a, vector signed long long __b) {
7304  return __a | __b;
7305 }
7306 
7307 static __inline__ vector signed long long __ATTRS_o_ai
7308 vec_vor(vector bool long long __a, vector signed long long __b) {
7309  return (vector signed long long)__a | __b;
7310 }
7311 
7312 static __inline__ vector signed long long __ATTRS_o_ai
7313 vec_vor(vector signed long long __a, vector bool long long __b) {
7314  return __a | (vector signed long long)__b;
7315 }
7316 
7317 static __inline__ vector unsigned long long __ATTRS_o_ai
7318 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
7319  return __a | __b;
7320 }
7321 
7322 static __inline__ vector unsigned long long __ATTRS_o_ai
7323 vec_vor(vector bool long long __a, vector unsigned long long __b) {
7324  return (vector unsigned long long)__a | __b;
7325 }
7326 
7327 static __inline__ vector unsigned long long __ATTRS_o_ai
7328 vec_vor(vector unsigned long long __a, vector bool long long __b) {
7329  return __a | (vector unsigned long long)__b;
7330 }
7331 
7332 static __inline__ vector bool long long __ATTRS_o_ai
7333 vec_vor(vector bool long long __a, vector bool long long __b) {
7334  return __a | __b;
7335 }
7336 #endif
7337 
7338 /* vec_pack */
7339 
7340 /* The various vector pack instructions have a big-endian bias, so for
7341  little endian we must handle reversed element numbering. */
7342 
7343 static __inline__ vector signed char __ATTRS_o_ai
7344 vec_pack(vector signed short __a, vector signed short __b) {
7345 #ifdef __LITTLE_ENDIAN__
7346  return (vector signed char)vec_perm(
7347  __a, __b,
7348  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7349  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7350 #else
7351  return (vector signed char)vec_perm(
7352  __a, __b,
7353  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7354  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7355 #endif
7356 }
7357 
7358 static __inline__ vector unsigned char __ATTRS_o_ai
7359 vec_pack(vector unsigned short __a, vector unsigned short __b) {
7360 #ifdef __LITTLE_ENDIAN__
7361  return (vector unsigned char)vec_perm(
7362  __a, __b,
7363  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7364  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7365 #else
7366  return (vector unsigned char)vec_perm(
7367  __a, __b,
7368  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7369  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7370 #endif
7371 }
7372 
7373 static __inline__ vector bool char __ATTRS_o_ai
7374 vec_pack(vector bool short __a, vector bool short __b) {
7375 #ifdef __LITTLE_ENDIAN__
7376  return (vector bool char)vec_perm(
7377  __a, __b,
7378  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7379  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7380 #else
7381  return (vector bool char)vec_perm(
7382  __a, __b,
7383  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7384  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7385 #endif
7386 }
7387 
7388 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
7389  vector int __b) {
7390 #ifdef __LITTLE_ENDIAN__
7391  return (vector short)vec_perm(
7392  __a, __b,
7393  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7394  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7395 #else
7396  return (vector short)vec_perm(
7397  __a, __b,
7398  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7399  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7400 #endif
7401 }
7402 
7403 static __inline__ vector unsigned short __ATTRS_o_ai
7404 vec_pack(vector unsigned int __a, vector unsigned int __b) {
7405 #ifdef __LITTLE_ENDIAN__
7406  return (vector unsigned short)vec_perm(
7407  __a, __b,
7408  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7409  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7410 #else
7411  return (vector unsigned short)vec_perm(
7412  __a, __b,
7413  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7414  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7415 #endif
7416 }
7417 
7418 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
7419  vector bool int __b) {
7420 #ifdef __LITTLE_ENDIAN__
7421  return (vector bool short)vec_perm(
7422  __a, __b,
7423  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7424  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7425 #else
7426  return (vector bool short)vec_perm(
7427  __a, __b,
7428  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7429  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7430 #endif
7431 }
7432 
7433 #ifdef __VSX__
7434 static __inline__ vector signed int __ATTRS_o_ai
7435 vec_pack(vector signed long long __a, vector signed long long __b) {
7436 #ifdef __LITTLE_ENDIAN__
7437  return (vector signed int)vec_perm(
7438  __a, __b,
7439  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7440  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7441 #else
7442  return (vector signed int)vec_perm(
7443  __a, __b,
7444  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7445  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7446 #endif
7447 }
7448 static __inline__ vector unsigned int __ATTRS_o_ai
7449 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
7450 #ifdef __LITTLE_ENDIAN__
7451  return (vector unsigned int)vec_perm(
7452  __a, __b,
7453  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7454  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7455 #else
7456  return (vector unsigned int)vec_perm(
7457  __a, __b,
7458  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7459  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7460 #endif
7461 }
7462 
7463 static __inline__ vector bool int __ATTRS_o_ai
7464 vec_pack(vector bool long long __a, vector bool long long __b) {
7465 #ifdef __LITTLE_ENDIAN__
7466  return (vector bool int)vec_perm(
7467  __a, __b,
7468  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7469  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7470 #else
7471  return (vector bool int)vec_perm(
7472  __a, __b,
7473  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7474  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7475 #endif
7476 }
7477 
7478 static __inline__ vector float __ATTRS_o_ai
7479 vec_pack(vector double __a, vector double __b) {
7480  return (vector float) (__a[0], __a[1], __b[0], __b[1]);
7481 }
7482 #endif
7483 
7484 #ifdef __POWER9_VECTOR__
7485 static __inline__ vector unsigned short __ATTRS_o_ai
7486 vec_pack_to_short_fp32(vector float __a, vector float __b) {
7487  vector float __resa = __builtin_vsx_xvcvsphp(__a);
7488  vector float __resb = __builtin_vsx_xvcvsphp(__b);
7489 #ifdef __LITTLE_ENDIAN__
7490  return (vector unsigned short)vec_mergee(__resa, __resb);
7491 #else
7492  return (vector unsigned short)vec_mergeo(__resa, __resb);
7493 #endif
7494 }
7495 
7496 #endif
7497 /* vec_vpkuhum */
7498 
7499 #define __builtin_altivec_vpkuhum vec_vpkuhum
7500 
7501 static __inline__ vector signed char __ATTRS_o_ai
7502 vec_vpkuhum(vector signed short __a, vector signed short __b) {
7503 #ifdef __LITTLE_ENDIAN__
7504  return (vector signed char)vec_perm(
7505  __a, __b,
7506  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7507  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7508 #else
7509  return (vector signed char)vec_perm(
7510  __a, __b,
7511  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7512  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7513 #endif
7514 }
7515 
7516 static __inline__ vector unsigned char __ATTRS_o_ai
7517 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
7518 #ifdef __LITTLE_ENDIAN__
7519  return (vector unsigned char)vec_perm(
7520  __a, __b,
7521  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7522  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7523 #else
7524  return (vector unsigned char)vec_perm(
7525  __a, __b,
7526  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7527  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7528 #endif
7529 }
7530 
7531 static __inline__ vector bool char __ATTRS_o_ai
7532 vec_vpkuhum(vector bool short __a, vector bool short __b) {
7533 #ifdef __LITTLE_ENDIAN__
7534  return (vector bool char)vec_perm(
7535  __a, __b,
7536  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7537  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7538 #else
7539  return (vector bool char)vec_perm(
7540  __a, __b,
7541  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7542  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7543 #endif
7544 }
7545 
7546 /* vec_vpkuwum */
7547 
7548 #define __builtin_altivec_vpkuwum vec_vpkuwum
7549 
7550 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
7551  vector int __b) {
7552 #ifdef __LITTLE_ENDIAN__
7553  return (vector short)vec_perm(
7554  __a, __b,
7555  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7556  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7557 #else
7558  return (vector short)vec_perm(
7559  __a, __b,
7560  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7561  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7562 #endif
7563 }
7564 
7565 static __inline__ vector unsigned short __ATTRS_o_ai
7566 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
7567 #ifdef __LITTLE_ENDIAN__
7568  return (vector unsigned short)vec_perm(
7569  __a, __b,
7570  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7571  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7572 #else
7573  return (vector unsigned short)vec_perm(
7574  __a, __b,
7575  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7576  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7577 #endif
7578 }
7579 
7580 static __inline__ vector bool short __ATTRS_o_ai
7581 vec_vpkuwum(vector bool int __a, vector bool int __b) {
7582 #ifdef __LITTLE_ENDIAN__
7583  return (vector bool short)vec_perm(
7584  __a, __b,
7585  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7586  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7587 #else
7588  return (vector bool short)vec_perm(
7589  __a, __b,
7590  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7591  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7592 #endif
7593 }
7594 
7595 /* vec_vpkudum */
7596 
7597 #ifdef __POWER8_VECTOR__
7598 #define __builtin_altivec_vpkudum vec_vpkudum
7599 
7600 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
7601  vector long long __b) {
7602 #ifdef __LITTLE_ENDIAN__
7603  return (vector int)vec_perm(
7604  __a, __b,
7605  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7606  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7607 #else
7608  return (vector int)vec_perm(
7609  __a, __b,
7610  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7611  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7612 #endif
7613 }
7614 
7615 static __inline__ vector unsigned int __ATTRS_o_ai
7616 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
7617 #ifdef __LITTLE_ENDIAN__
7618  return (vector unsigned int)vec_perm(
7619  __a, __b,
7620  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7621  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7622 #else
7623  return (vector unsigned int)vec_perm(
7624  __a, __b,
7625  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7626  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7627 #endif
7628 }
7629 
7630 static __inline__ vector bool int __ATTRS_o_ai
7631 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
7632 #ifdef __LITTLE_ENDIAN__
7633  return (vector bool int)vec_perm(
7634  (vector long long)__a, (vector long long)__b,
7635  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7636  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7637 #else
7638  return (vector bool int)vec_perm(
7639  (vector long long)__a, (vector long long)__b,
7640  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7641  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7642 #endif
7643 }
7644 #endif
7645 
7646 /* vec_packpx */
7647 
7648 static __inline__ vector pixel __attribute__((__always_inline__))
7649 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
7650 #ifdef __LITTLE_ENDIAN__
7651  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7652 #else
7653  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7654 #endif
7655 }
7656 
7657 /* vec_vpkpx */
7658 
7659 static __inline__ vector pixel __attribute__((__always_inline__))
7660 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
7661 #ifdef __LITTLE_ENDIAN__
7662  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7663 #else
7664  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7665 #endif
7666 }
7667 
7668 /* vec_packs */
7669 
7670 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
7671  vector short __b) {
7672 #ifdef __LITTLE_ENDIAN__
7673  return __builtin_altivec_vpkshss(__b, __a);
7674 #else
7675  return __builtin_altivec_vpkshss(__a, __b);
7676 #endif
7677 }
7678 
7679 static __inline__ vector unsigned char __ATTRS_o_ai
7680 vec_packs(vector unsigned short __a, vector unsigned short __b) {
7681 #ifdef __LITTLE_ENDIAN__
7682  return __builtin_altivec_vpkuhus(__b, __a);
7683 #else
7684  return __builtin_altivec_vpkuhus(__a, __b);
7685 #endif
7686 }
7687 
7688 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
7689  vector int __b) {
7690 #ifdef __LITTLE_ENDIAN__
7691  return __builtin_altivec_vpkswss(__b, __a);
7692 #else
7693  return __builtin_altivec_vpkswss(__a, __b);
7694 #endif
7695 }
7696 
7697 static __inline__ vector unsigned short __ATTRS_o_ai
7698 vec_packs(vector unsigned int __a, vector unsigned int __b) {
7699 #ifdef __LITTLE_ENDIAN__
7700  return __builtin_altivec_vpkuwus(__b, __a);
7701 #else
7702  return __builtin_altivec_vpkuwus(__a, __b);
7703 #endif
7704 }
7705 
7706 #ifdef __POWER8_VECTOR__
7707 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
7708  vector long long __b) {
7709 #ifdef __LITTLE_ENDIAN__
7710  return __builtin_altivec_vpksdss(__b, __a);
7711 #else
7712  return __builtin_altivec_vpksdss(__a, __b);
7713 #endif
7714 }
7715 
7716 static __inline__ vector unsigned int __ATTRS_o_ai
7717 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
7718 #ifdef __LITTLE_ENDIAN__
7719  return __builtin_altivec_vpkudus(__b, __a);
7720 #else
7721  return __builtin_altivec_vpkudus(__a, __b);
7722 #endif
7723 }
7724 #endif
7725 
7726 /* vec_vpkshss */
7727 
7728 static __inline__ vector signed char __attribute__((__always_inline__))
7729 vec_vpkshss(vector short __a, vector short __b) {
7730 #ifdef __LITTLE_ENDIAN__
7731  return __builtin_altivec_vpkshss(__b, __a);
7732 #else
7733  return __builtin_altivec_vpkshss(__a, __b);
7734 #endif
7735 }
7736 
7737 /* vec_vpksdss */
7738 
7739 #ifdef __POWER8_VECTOR__
7740 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
7741  vector long long __b) {
7742 #ifdef __LITTLE_ENDIAN__
7743  return __builtin_altivec_vpksdss(__b, __a);
7744 #else
7745  return __builtin_altivec_vpksdss(__a, __b);
7746 #endif
7747 }
7748 #endif
7749 
7750 /* vec_vpkuhus */
7751 
7752 static __inline__ vector unsigned char __attribute__((__always_inline__))
7753 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
7754 #ifdef __LITTLE_ENDIAN__
7755  return __builtin_altivec_vpkuhus(__b, __a);
7756 #else
7757  return __builtin_altivec_vpkuhus(__a, __b);
7758 #endif
7759 }
7760 
7761 /* vec_vpkudus */
7762 
7763 #ifdef __POWER8_VECTOR__
7764 static __inline__ vector unsigned int __attribute__((__always_inline__))
7765 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
7766 #ifdef __LITTLE_ENDIAN__
7767  return __builtin_altivec_vpkudus(__b, __a);
7768 #else
7769  return __builtin_altivec_vpkudus(__a, __b);
7770 #endif
7771 }
7772 #endif
7773 
7774 /* vec_vpkswss */
7775 
7776 static __inline__ vector signed short __attribute__((__always_inline__))
7777 vec_vpkswss(vector int __a, vector int __b) {
7778 #ifdef __LITTLE_ENDIAN__
7779  return __builtin_altivec_vpkswss(__b, __a);
7780 #else
7781  return __builtin_altivec_vpkswss(__a, __b);
7782 #endif
7783 }
7784 
7785 /* vec_vpkuwus */
7786 
7787 static __inline__ vector unsigned short __attribute__((__always_inline__))
7788 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
7789 #ifdef __LITTLE_ENDIAN__
7790  return __builtin_altivec_vpkuwus(__b, __a);
7791 #else
7792  return __builtin_altivec_vpkuwus(__a, __b);
7793 #endif
7794 }
7795 
7796 /* vec_packsu */
7797 
7798 static __inline__ vector unsigned char __ATTRS_o_ai
7799 vec_packsu(vector short __a, vector short __b) {
7800 #ifdef __LITTLE_ENDIAN__
7801  return __builtin_altivec_vpkshus(__b, __a);
7802 #else
7803  return __builtin_altivec_vpkshus(__a, __b);
7804 #endif
7805 }
7806 
7807 static __inline__ vector unsigned char __ATTRS_o_ai
7808 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
7809 #ifdef __LITTLE_ENDIAN__
7810  return __builtin_altivec_vpkuhus(__b, __a);
7811 #else
7812  return __builtin_altivec_vpkuhus(__a, __b);
7813 #endif
7814 }
7815 
7816 static __inline__ vector unsigned short __ATTRS_o_ai
7817 vec_packsu(vector int __a, vector int __b) {
7818 #ifdef __LITTLE_ENDIAN__
7819  return __builtin_altivec_vpkswus(__b, __a);
7820 #else
7821  return __builtin_altivec_vpkswus(__a, __b);
7822 #endif
7823 }
7824 
7825 static __inline__ vector unsigned short __ATTRS_o_ai
7826 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
7827 #ifdef __LITTLE_ENDIAN__
7828  return __builtin_altivec_vpkuwus(__b, __a);
7829 #else
7830  return __builtin_altivec_vpkuwus(__a, __b);
7831 #endif
7832 }
7833 
7834 #ifdef __POWER8_VECTOR__
7835 static __inline__ vector unsigned int __ATTRS_o_ai
7836 vec_packsu(vector long long __a, vector long long __b) {
7837 #ifdef __LITTLE_ENDIAN__
7838  return __builtin_altivec_vpksdus(__b, __a);
7839 #else
7840  return __builtin_altivec_vpksdus(__a, __b);
7841 #endif
7842 }
7843 
7844 static __inline__ vector unsigned int __ATTRS_o_ai
7845 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
7846 #ifdef __LITTLE_ENDIAN__
7847  return __builtin_altivec_vpkudus(__b, __a);
7848 #else
7849  return __builtin_altivec_vpkudus(__a, __b);
7850 #endif
7851 }
7852 #endif
7853 
7854 /* vec_vpkshus */
7855 
7856 static __inline__ vector unsigned char __ATTRS_o_ai
7857 vec_vpkshus(vector short __a, vector short __b) {
7858 #ifdef __LITTLE_ENDIAN__
7859  return __builtin_altivec_vpkshus(__b, __a);
7860 #else
7861  return __builtin_altivec_vpkshus(__a, __b);
7862 #endif
7863 }
7864 
7865 static __inline__ vector unsigned char __ATTRS_o_ai
7866 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
7867 #ifdef __LITTLE_ENDIAN__
7868  return __builtin_altivec_vpkuhus(__b, __a);
7869 #else
7870  return __builtin_altivec_vpkuhus(__a, __b);
7871 #endif
7872 }
7873 
7874 /* vec_vpkswus */
7875 
7876 static __inline__ vector unsigned short __ATTRS_o_ai
7877 vec_vpkswus(vector int __a, vector int __b) {
7878 #ifdef __LITTLE_ENDIAN__
7879  return __builtin_altivec_vpkswus(__b, __a);
7880 #else
7881  return __builtin_altivec_vpkswus(__a, __b);
7882 #endif
7883 }
7884 
7885 static __inline__ vector unsigned short __ATTRS_o_ai
7886 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
7887 #ifdef __LITTLE_ENDIAN__
7888  return __builtin_altivec_vpkuwus(__b, __a);
7889 #else
7890  return __builtin_altivec_vpkuwus(__a, __b);
7891 #endif
7892 }
7893 
7894 /* vec_vpksdus */
7895 
7896 #ifdef __POWER8_VECTOR__
7897 static __inline__ vector unsigned int __ATTRS_o_ai
7898 vec_vpksdus(vector long long __a, vector long long __b) {
7899 #ifdef __LITTLE_ENDIAN__
7900  return __builtin_altivec_vpksdus(__b, __a);
7901 #else
7902  return __builtin_altivec_vpksdus(__a, __b);
7903 #endif
7904 }
7905 #endif
7906 
7907 /* vec_perm */
7908 
7909 // The vperm instruction is defined architecturally with a big-endian bias.
7910 // For little endian, we swap the input operands and invert the permute
7911 // control vector. Only the rightmost 5 bits matter, so we could use
7912 // a vector of all 31s instead of all 255s to perform the inversion.
7913 // However, when the PCV is not a constant, using 255 has an advantage
7914 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
7915 // later, possibly a vec_nand).
7916 
7917 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
7918  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7919 #ifdef __LITTLE_ENDIAN__
7920  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7921  255, 255, 255, 255, 255, 255, 255, 255};
7922  __d = vec_xor(__c, __d);
7923  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
7924  (vector int)__a, __d);
7925 #else
7926  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
7927  (vector int)__b, __c);
7928 #endif
7929 }
7930 
7931 static __inline__ vector unsigned char __ATTRS_o_ai
7932 vec_perm(vector unsigned char __a, vector unsigned char __b,
7933  vector unsigned char __c) {
7934 #ifdef __LITTLE_ENDIAN__
7935  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7936  255, 255, 255, 255, 255, 255, 255, 255};
7937  __d = vec_xor(__c, __d);
7938  return (vector unsigned char)__builtin_altivec_vperm_4si(
7939  (vector int)__b, (vector int)__a, __d);
7940 #else
7941  return (vector unsigned char)__builtin_altivec_vperm_4si(
7942  (vector int)__a, (vector int)__b, __c);
7943 #endif
7944 }
7945 
7946 static __inline__ vector bool char __ATTRS_o_ai
7947 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7948 #ifdef __LITTLE_ENDIAN__
7949  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7950  255, 255, 255, 255, 255, 255, 255, 255};
7951  __d = vec_xor(__c, __d);
7952  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
7953  (vector int)__a, __d);
7954 #else
7955  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
7956  (vector int)__b, __c);
7957 #endif
7958 }
7959 
7960 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
7961  vector signed short __b,
7962  vector unsigned char __c) {
7963 #ifdef __LITTLE_ENDIAN__
7964  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7965  255, 255, 255, 255, 255, 255, 255, 255};
7966  __d = vec_xor(__c, __d);
7967  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
7968  (vector int)__a, __d);
7969 #else
7970  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
7971  (vector int)__b, __c);
7972 #endif
7973 }
7974 
7975 static __inline__ vector unsigned short __ATTRS_o_ai
7976 vec_perm(vector unsigned short __a, vector unsigned short __b,
7977  vector unsigned char __c) {
7978 #ifdef __LITTLE_ENDIAN__
7979  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7980  255, 255, 255, 255, 255, 255, 255, 255};
7981  __d = vec_xor(__c, __d);
7982  return (vector unsigned short)__builtin_altivec_vperm_4si(
7983  (vector int)__b, (vector int)__a, __d);
7984 #else
7985  return (vector unsigned short)__builtin_altivec_vperm_4si(
7986  (vector int)__a, (vector int)__b, __c);
7987 #endif
7988 }
7989 
7990 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
7991  vector bool short __a, vector bool short __b, vector unsigned char __c) {
7992 #ifdef __LITTLE_ENDIAN__
7993  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7994  255, 255, 255, 255, 255, 255, 255, 255};
7995  __d = vec_xor(__c, __d);
7996  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
7997  (vector int)__a, __d);
7998 #else
7999  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
8000  (vector int)__b, __c);
8001 #endif
8002 }
8003 
8004 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
8005  vector pixel __b,
8006  vector unsigned char __c) {
8007 #ifdef __LITTLE_ENDIAN__
8008  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8009  255, 255, 255, 255, 255, 255, 255, 255};
8010  __d = vec_xor(__c, __d);
8011  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
8012  (vector int)__a, __d);
8013 #else
8014  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
8015  (vector int)__b, __c);
8016 #endif
8017 }
8018 
8019 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
8020  vector signed int __b,
8021  vector unsigned char __c) {
8022 #ifdef __LITTLE_ENDIAN__
8023  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8024  255, 255, 255, 255, 255, 255, 255, 255};
8025  __d = vec_xor(__c, __d);
8026  return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
8027 #else
8028  return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
8029 #endif
8030 }
8031 
8032 static __inline__ vector unsigned int __ATTRS_o_ai
8033 vec_perm(vector unsigned int __a, vector unsigned int __b,
8034  vector unsigned char __c) {
8035 #ifdef __LITTLE_ENDIAN__
8036  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8037  255, 255, 255, 255, 255, 255, 255, 255};
8038  __d = vec_xor(__c, __d);
8039  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
8040  (vector int)__a, __d);
8041 #else
8042  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
8043  (vector int)__b, __c);
8044 #endif
8045 }
8046 
8047 static __inline__ vector bool int __ATTRS_o_ai
8048 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
8049 #ifdef __LITTLE_ENDIAN__
8050  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8051  255, 255, 255, 255, 255, 255, 255, 255};
8052  __d = vec_xor(__c, __d);
8053  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
8054  (vector int)__a, __d);
8055 #else
8056  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
8057  (vector int)__b, __c);
8058 #endif
8059 }
8060 
8061 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
8062  vector float __b,
8063  vector unsigned char __c) {
8064 #ifdef __LITTLE_ENDIAN__
8065  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8066  255, 255, 255, 255, 255, 255, 255, 255};
8067  __d = vec_xor(__c, __d);
8068  return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
8069  (vector int)__a, __d);
8070 #else
8071  return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
8072  (vector int)__b, __c);
8073 #endif
8074 }
8075 
8076 #ifdef __VSX__
8077 static __inline__ vector long long __ATTRS_o_ai
8078 vec_perm(vector signed long long __a, vector signed long long __b,
8079  vector unsigned char __c) {
8080 #ifdef __LITTLE_ENDIAN__
8081  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8082  255, 255, 255, 255, 255, 255, 255, 255};
8083  __d = vec_xor(__c, __d);
8084  return (vector signed long long)__builtin_altivec_vperm_4si(
8085  (vector int)__b, (vector int)__a, __d);
8086 #else
8087  return (vector signed long long)__builtin_altivec_vperm_4si(
8088  (vector int)__a, (vector int)__b, __c);
8089 #endif
8090 }
8091 
8092 static __inline__ vector unsigned long long __ATTRS_o_ai
8093 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
8094  vector unsigned char __c) {
8095 #ifdef __LITTLE_ENDIAN__
8096  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8097  255, 255, 255, 255, 255, 255, 255, 255};
8098  __d = vec_xor(__c, __d);
8099  return (vector unsigned long long)__builtin_altivec_vperm_4si(
8100  (vector int)__b, (vector int)__a, __d);
8101 #else
8102  return (vector unsigned long long)__builtin_altivec_vperm_4si(
8103  (vector int)__a, (vector int)__b, __c);
8104 #endif
8105 }
8106 
8107 static __inline__ vector bool long long __ATTRS_o_ai
8108 vec_perm(vector bool long long __a, vector bool long long __b,
8109  vector unsigned char __c) {
8110 #ifdef __LITTLE_ENDIAN__
8111  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8112  255, 255, 255, 255, 255, 255, 255, 255};
8113  __d = vec_xor(__c, __d);
8114  return (vector bool long long)__builtin_altivec_vperm_4si(
8115  (vector int)__b, (vector int)__a, __d);
8116 #else
8117  return (vector bool long long)__builtin_altivec_vperm_4si(
8118  (vector int)__a, (vector int)__b, __c);
8119 #endif
8120 }
8121 
8122 static __inline__ vector double __ATTRS_o_ai
8123 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
8124 #ifdef __LITTLE_ENDIAN__
8125  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8126  255, 255, 255, 255, 255, 255, 255, 255};
8127  __d = vec_xor(__c, __d);
8128  return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
8129  (vector int)__a, __d);
8130 #else
8131  return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
8132  (vector int)__b, __c);
8133 #endif
8134 }
8135 #endif
8136 
8137 /* vec_vperm */
8138 
8139 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
8140  vector signed char __a, vector signed char __b, vector unsigned char __c) {
8141  return vec_perm(__a, __b, __c);
8142 }
8143 
8144 static __inline__ vector unsigned char __ATTRS_o_ai
8145 vec_vperm(vector unsigned char __a, vector unsigned char __b,
8146  vector unsigned char __c) {
8147  return vec_perm(__a, __b, __c);
8148 }
8149 
8150 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
8151  vector bool char __a, vector bool char __b, vector unsigned char __c) {
8152  return vec_perm(__a, __b, __c);
8153 }
8154 
8155 static __inline__ vector short __ATTRS_o_ai
8156 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
8157  return vec_perm(__a, __b, __c);
8158 }
8159 
8160 static __inline__ vector unsigned short __ATTRS_o_ai
8161 vec_vperm(vector unsigned short __a, vector unsigned short __b,
8162  vector unsigned char __c) {
8163  return vec_perm(__a, __b, __c);
8164 }
8165 
8166 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
8167  vector bool short __a, vector bool short __b, vector unsigned char __c) {
8168  return vec_perm(__a, __b, __c);
8169 }
8170 
8171 static __inline__ vector pixel __ATTRS_o_ai
8172 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
8173  return vec_perm(__a, __b, __c);
8174 }
8175 
8176 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
8177  vector int __b,
8178  vector unsigned char __c) {
8179  return vec_perm(__a, __b, __c);
8180 }
8181 
8182 static __inline__ vector unsigned int __ATTRS_o_ai
8183 vec_vperm(vector unsigned int __a, vector unsigned int __b,
8184  vector unsigned char __c) {
8185  return vec_perm(__a, __b, __c);
8186 }
8187 
8188 static __inline__ vector bool int __ATTRS_o_ai
8189 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
8190  return vec_perm(__a, __b, __c);
8191 }
8192 
8193 static __inline__ vector float __ATTRS_o_ai
8194 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
8195  return vec_perm(__a, __b, __c);
8196 }
8197 
8198 #ifdef __VSX__
8199 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
8200  vector long long __a, vector long long __b, vector unsigned char __c) {
8201  return vec_perm(__a, __b, __c);
8202 }
8203 
8204 static __inline__ vector unsigned long long __ATTRS_o_ai
8205 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
8206  vector unsigned char __c) {
8207  return vec_perm(__a, __b, __c);
8208 }
8209 
8210 static __inline__ vector double __ATTRS_o_ai
8211 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
8212  return vec_perm(__a, __b, __c);
8213 }
8214 #endif
8215 
8216 /* vec_re */
8217 
8218 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
8219 #ifdef __VSX__
8220  return __builtin_vsx_xvresp(__a);
8221 #else
8222  return __builtin_altivec_vrefp(__a);
8223 #endif
8224 }
8225 
8226 #ifdef __VSX__
8227 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
8228  return __builtin_vsx_xvredp(__a);
8229 }
8230 #endif
8231 
8232 /* vec_vrefp */
8233 
8234 static __inline__ vector float __attribute__((__always_inline__))
8235 vec_vrefp(vector float __a) {
8236  return __builtin_altivec_vrefp(__a);
8237 }
8238 
8239 /* vec_rl */
8240 
8241 static __inline__ vector signed char __ATTRS_o_ai
8242 vec_rl(vector signed char __a, vector unsigned char __b) {
8243  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
8244 }
8245 
8246 static __inline__ vector unsigned char __ATTRS_o_ai
8247 vec_rl(vector unsigned char __a, vector unsigned char __b) {
8248  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
8249 }
8250 
8251 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
8252  vector unsigned short __b) {
8253  return __builtin_altivec_vrlh(__a, __b);
8254 }
8255 
8256 static __inline__ vector unsigned short __ATTRS_o_ai
8257 vec_rl(vector unsigned short __a, vector unsigned short __b) {
8258  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
8259 }
8260 
8261 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
8262  vector unsigned int __b) {
8263  return __builtin_altivec_vrlw(__a, __b);
8264 }
8265 
8266 static __inline__ vector unsigned int __ATTRS_o_ai
8267 vec_rl(vector unsigned int __a, vector unsigned int __b) {
8268  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
8269 }
8270 
8271 #ifdef __POWER8_VECTOR__
8272 static __inline__ vector signed long long __ATTRS_o_ai
8273 vec_rl(vector signed long long __a, vector unsigned long long __b) {
8274  return __builtin_altivec_vrld(__a, __b);
8275 }
8276 
8277 static __inline__ vector unsigned long long __ATTRS_o_ai
8278 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
8279  return __builtin_altivec_vrld(__a, __b);
8280 }
8281 #endif
8282 
8283 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8284 static __inline__ vector signed __int128 __ATTRS_o_ai
8285 vec_rl(vector signed __int128 __a, vector unsigned __int128 __b) {
8286  return (__b << __a)|(__b >> ((__CHAR_BIT__ * sizeof(vector signed __int128)) - __a));
8287 }
8288 
8289 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8290 vec_rl(vector unsigned __int128 __a, vector unsigned __int128 __b) {
8291  return (__b << __a)|(__b >> ((__CHAR_BIT__ * sizeof(vector unsigned __int128)) - __a));
8292 }
8293 #endif
8294 
8295 /* vec_rlmi */
8296 #ifdef __POWER9_VECTOR__
8297 static __inline__ vector unsigned int __ATTRS_o_ai
8298 vec_rlmi(vector unsigned int __a, vector unsigned int __b,
8299  vector unsigned int __c) {
8300  return __builtin_altivec_vrlwmi(__a, __c, __b);
8301 }
8302 
8303 static __inline__ vector unsigned long long __ATTRS_o_ai
8304 vec_rlmi(vector unsigned long long __a, vector unsigned long long __b,
8305  vector unsigned long long __c) {
8306  return __builtin_altivec_vrldmi(__a, __c, __b);
8307 }
8308 #endif
8309 
8310 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8311 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8312 vec_rlmi(vector unsigned __int128 __a, vector unsigned __int128 __b,
8313  vector unsigned __int128 __c) {
8314  return __builtin_altivec_vrlqmi(__a, __c, __b);
8315 }
8316 
8317 static __inline__ vector signed __int128 __ATTRS_o_ai
8318 vec_rlmi(vector signed __int128 __a, vector signed __int128 __b,
8319  vector signed __int128 __c) {
8320  return __builtin_altivec_vrlqmi(__a, __c, __b);
8321 }
8322 #endif
8323 
8324 /* vec_rlnm */
8325 #ifdef __POWER9_VECTOR__
8326 static __inline__ vector unsigned int __ATTRS_o_ai
8327 vec_rlnm(vector unsigned int __a, vector unsigned int __b,
8328  vector unsigned int __c) {
8329  vector unsigned int OneByte = { 0x8, 0x8, 0x8, 0x8 };
8330  return __builtin_altivec_vrlwnm(__a, ((__c << OneByte) | __b));
8331 }
8332 
8333 static __inline__ vector unsigned long long __ATTRS_o_ai
8334 vec_rlnm(vector unsigned long long __a, vector unsigned long long __b,
8335  vector unsigned long long __c) {
8336  vector unsigned long long OneByte = { 0x8, 0x8 };
8337  return __builtin_altivec_vrldnm(__a, ((__c << OneByte) | __b));
8338 }
8339 #endif
8340 
8341 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8342 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8343 vec_rlnm(vector unsigned __int128 __a, vector unsigned __int128 __b,
8344  vector unsigned __int128 __c) {
8345  // Merge __b and __c using an appropriate shuffle.
8346  vector unsigned char TmpB = (vector unsigned char)__b;
8347  vector unsigned char TmpC = (vector unsigned char)__c;
8348  vector unsigned char MaskAndShift =
8349 #ifdef __LITTLE_ENDIAN__
8350  __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, -1, -1, -1, 16, 0,
8351  1, -1, -1, -1, -1, -1);
8352 #else
8353  __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, 31, 30, 15, -1,
8354  -1, -1, -1, -1, -1, -1, -1);
8355 #endif
8356  return __builtin_altivec_vrlqnm(__a, (vector unsigned __int128) MaskAndShift);
8357 }
8358 
8359 static __inline__ vector signed __int128 __ATTRS_o_ai
8360 vec_rlnm(vector signed __int128 __a, vector signed __int128 __b,
8361  vector signed __int128 __c) {
8362  // Merge __b and __c using an appropriate shuffle.
8363  vector unsigned char TmpB = (vector unsigned char)__b;
8364  vector unsigned char TmpC = (vector unsigned char)__c;
8365  vector unsigned char MaskAndShift =
8366 #ifdef __LITTLE_ENDIAN__
8367  __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, -1, -1, -1, 16, 0,
8368  1, -1, -1, -1, -1, -1);
8369 #else
8370  __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, 31, 30, 15, -1,
8371  -1, -1, -1, -1, -1, -1, -1);
8372 #endif
8373  return __builtin_altivec_vrlqnm(__a, (vector unsigned __int128) MaskAndShift);
8374 }
8375 #endif
8376 
8377 /* vec_vrlb */
8378 
8379 static __inline__ vector signed char __ATTRS_o_ai
8380 vec_vrlb(vector signed char __a, vector unsigned char __b) {
8381  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
8382 }
8383 
8384 static __inline__ vector unsigned char __ATTRS_o_ai
8385 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
8386  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
8387 }
8388 
8389 /* vec_vrlh */
8390 
8391 static __inline__ vector short __ATTRS_o_ai
8392 vec_vrlh(vector short __a, vector unsigned short __b) {
8393  return __builtin_altivec_vrlh(__a, __b);
8394 }
8395 
8396 static __inline__ vector unsigned short __ATTRS_o_ai
8397 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
8398  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
8399 }
8400 
8401 /* vec_vrlw */
8402 
8403 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
8404  vector unsigned int __b) {
8405  return __builtin_altivec_vrlw(__a, __b);
8406 }
8407 
8408 static __inline__ vector unsigned int __ATTRS_o_ai
8409 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
8410  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
8411 }
8412 
8413 /* vec_round */
8414 
8415 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
8416  return __builtin_altivec_vrfin(__a);
8417 }
8418 
8419 #ifdef __VSX__
8420 #ifdef __XL_COMPAT_ALTIVEC__
8421 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a);
8422 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
8423  double __fpscr = __builtin_readflm();
8424  __builtin_setrnd(0);
8425  vector double __rounded = vec_rint(__a);
8426  __builtin_setflm(__fpscr);
8427  return __rounded;
8428 }
8429 #else
8430 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
8431  return __builtin_vsx_xvrdpi(__a);
8432 }
8433 #endif
8434 
8435 /* vec_rint */
8436 
8437 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
8438  return __builtin_vsx_xvrspic(__a);
8439 }
8440 
8441 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
8442  return __builtin_vsx_xvrdpic(__a);
8443 }
8444 
8445 /* vec_roundc */
8446 
8447 static __inline__ vector float __ATTRS_o_ai vec_roundc(vector float __a) {
8448  return __builtin_vsx_xvrspic(__a);
8449 }
8450 
8451 static __inline__ vector double __ATTRS_o_ai vec_roundc(vector double __a) {
8452  return __builtin_vsx_xvrdpic(__a);
8453 }
8454 
8455 /* vec_nearbyint */
8456 
8457 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
8458  return __builtin_vsx_xvrspi(__a);
8459 }
8460 
8461 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
8462  return __builtin_vsx_xvrdpi(__a);
8463 }
8464 #endif
8465 
8466 /* vec_vrfin */
8467 
8468 static __inline__ vector float __attribute__((__always_inline__))
8469 vec_vrfin(vector float __a) {
8470  return __builtin_altivec_vrfin(__a);
8471 }
8472 
8473 /* vec_sqrt */
8474 
8475 #ifdef __VSX__
8476 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
8477  return __builtin_vsx_xvsqrtsp(__a);
8478 }
8479 
8480 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
8481  return __builtin_vsx_xvsqrtdp(__a);
8482 }
8483 #endif
8484 
8485 /* vec_rsqrte */
8486 
8487 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
8488 #ifdef __VSX__
8489  return __builtin_vsx_xvrsqrtesp(__a);
8490 #else
8491  return __builtin_altivec_vrsqrtefp(__a);
8492 #endif
8493 }
8494 
8495 #ifdef __VSX__
8496 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
8497  return __builtin_vsx_xvrsqrtedp(__a);
8498 }
8499 #endif
8500 
8501 static vector float __ATTRS_o_ai vec_rsqrt(vector float __a) {
8502  return __builtin_ppc_rsqrtf(__a);
8503 }
8504 
8505 #ifdef __VSX__
8506 static vector double __ATTRS_o_ai vec_rsqrt(vector double __a) {
8507  return __builtin_ppc_rsqrtd(__a);
8508 }
8509 #endif
8510 
8511 /* vec_vrsqrtefp */
8512 
8513 static __inline__ __vector float __attribute__((__always_inline__))
8514 vec_vrsqrtefp(vector float __a) {
8515  return __builtin_altivec_vrsqrtefp(__a);
8516 }
8517 
8518 /* vec_xvtsqrt */
8519 
8520 #ifdef __VSX__
8521 static __inline__ int __ATTRS_o_ai vec_test_swsqrt(vector double __a) {
8522  return __builtin_vsx_xvtsqrtdp(__a);
8523 }
8524 
8525 static __inline__ int __ATTRS_o_ai vec_test_swsqrts(vector float __a) {
8526  return __builtin_vsx_xvtsqrtsp(__a);
8527 }
8528 #endif
8529 
8530 /* vec_sel */
8531 
8532 #define __builtin_altivec_vsel_4si vec_sel
8533 
8534 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
8535  vector signed char __a, vector signed char __b, vector unsigned char __c) {
8536  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8537 }
8538 
8539 static __inline__ vector signed char __ATTRS_o_ai
8540 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
8541  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8542 }
8543 
8544 static __inline__ vector unsigned char __ATTRS_o_ai
8545 vec_sel(vector unsigned char __a, vector unsigned char __b,
8546  vector unsigned char __c) {
8547  return (__a & ~__c) | (__b & __c);
8548 }
8549 
8550 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
8551  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
8552  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
8553 }
8554 
8555 static __inline__ vector bool char __ATTRS_o_ai
8556 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
8557  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
8558 }
8559 
8560 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
8561  vector bool char __b,
8562  vector bool char __c) {
8563  return (__a & ~__c) | (__b & __c);
8564 }
8565 
8566 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
8567  vector short __b,
8568  vector unsigned short __c) {
8569  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8570 }
8571 
8572 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
8573  vector short __b,
8574  vector bool short __c) {
8575  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8576 }
8577 
8578 static __inline__ vector unsigned short __ATTRS_o_ai
8579 vec_sel(vector unsigned short __a, vector unsigned short __b,
8580  vector unsigned short __c) {
8581  return (__a & ~__c) | (__b & __c);
8582 }
8583 
8584 static __inline__ vector unsigned short __ATTRS_o_ai
8585 vec_sel(vector unsigned short __a, vector unsigned short __b,
8586  vector bool short __c) {
8587  return (__a & ~(vector unsigned short)__c) |
8588  (__b & (vector unsigned short)__c);
8589 }
8590 
8591 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
8592  vector bool short __a, vector bool short __b, vector unsigned short __c) {
8593  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
8594 }
8595 
8596 static __inline__ vector bool short __ATTRS_o_ai
8597 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
8598  return (__a & ~__c) | (__b & __c);
8599 }
8600 
8601 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
8602  vector int __b,
8603  vector unsigned int __c) {
8604  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8605 }
8606 
8607 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
8608  vector int __b,
8609  vector bool int __c) {
8610  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8611 }
8612 
8613 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
8614  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8615  return (__a & ~__c) | (__b & __c);
8616 }
8617 
8618 static __inline__ vector unsigned int __ATTRS_o_ai
8619 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8620  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8621 }
8622 
8623 static __inline__ vector bool int __ATTRS_o_ai
8624 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8625  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8626 }
8627 
8628 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
8629  vector bool int __b,
8630  vector bool int __c) {
8631  return (__a & ~__c) | (__b & __c);
8632 }
8633 
8634 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
8635  vector float __b,
8636  vector unsigned int __c) {
8637  vector int __res = ((vector int)__a & ~(vector int)__c) |
8638  ((vector int)__b & (vector int)__c);
8639  return (vector float)__res;
8640 }
8641 
8642 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
8643  vector float __b,
8644  vector bool int __c) {
8645  vector int __res = ((vector int)__a & ~(vector int)__c) |
8646  ((vector int)__b & (vector int)__c);
8647  return (vector float)__res;
8648 }
8649 
8650 #ifdef __VSX__
8651 static __inline__ vector double __ATTRS_o_ai
8652 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
8653  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
8654  ((vector long long)__b & (vector long long)__c);
8655  return (vector double)__res;
8656 }
8657 
8658 static __inline__ vector double __ATTRS_o_ai
8659 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
8660  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
8661  ((vector long long)__b & (vector long long)__c);
8662  return (vector double)__res;
8663 }
8664 
8665 static __inline__ vector bool long long __ATTRS_o_ai
8666 vec_sel(vector bool long long __a, vector bool long long __b,
8667  vector bool long long __c) {
8668  return (__a & ~__c) | (__b & __c);
8669 }
8670 
8671 static __inline__ vector bool long long __ATTRS_o_ai
8672 vec_sel(vector bool long long __a, vector bool long long __b,
8673  vector unsigned long long __c) {
8674  return (__a & ~(vector bool long long)__c) |
8675  (__b & (vector bool long long)__c);
8676 }
8677 
8678 static __inline__ vector signed long long __ATTRS_o_ai
8679 vec_sel(vector signed long long __a, vector signed long long __b,
8680  vector bool long long __c) {
8681  return (__a & ~(vector signed long long)__c) |
8682  (__b & (vector signed long long)__c);
8683 }
8684 
8685 static __inline__ vector signed long long __ATTRS_o_ai
8686 vec_sel(vector signed long long __a, vector signed long long __b,
8687  vector unsigned long long __c) {
8688  return (__a & ~(vector signed long long)__c) |
8689  (__b & (vector signed long long)__c);
8690 }
8691 
8692 static __inline__ vector unsigned long long __ATTRS_o_ai
8693 vec_sel(vector unsigned long long __a, vector unsigned long long __b,
8694  vector bool long long __c) {
8695  return (__a & ~(vector unsigned long long)__c) |
8696  (__b & (vector unsigned long long)__c);
8697 }
8698 
8699 static __inline__ vector unsigned long long __ATTRS_o_ai
8700 vec_sel(vector unsigned long long __a, vector unsigned long long __b,
8701  vector unsigned long long __c) {
8702  return (__a & ~__c) | (__b & __c);
8703 }
8704 #endif
8705 
8706 /* vec_vsel */
8707 
8708 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
8709  vector signed char __a, vector signed char __b, vector unsigned char __c) {
8710  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8711 }
8712 
8713 static __inline__ vector signed char __ATTRS_o_ai
8714 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
8715  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8716 }
8717 
8718 static __inline__ vector unsigned char __ATTRS_o_ai
8719 vec_vsel(vector unsigned char __a, vector unsigned char __b,
8720  vector unsigned char __c) {
8721  return (__a & ~__c) | (__b & __c);
8722 }
8723 
8724 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
8725  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
8726  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
8727 }
8728 
8729 static __inline__ vector bool char __ATTRS_o_ai
8730 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
8731  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
8732 }
8733 
8734 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
8735  vector bool char __b,
8736  vector bool char __c) {
8737  return (__a & ~__c) | (__b & __c);
8738 }
8739 
8740 static __inline__ vector short __ATTRS_o_ai
8741 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
8742  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8743 }
8744 
8745 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
8746  vector short __b,
8747  vector bool short __c) {
8748  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8749 }
8750 
8751 static __inline__ vector unsigned short __ATTRS_o_ai
8752 vec_vsel(vector unsigned short __a, vector unsigned short __b,
8753  vector unsigned short __c) {
8754  return (__a & ~__c) | (__b & __c);
8755 }
8756 
8757 static __inline__ vector unsigned short __ATTRS_o_ai
8758 vec_vsel(vector unsigned short __a, vector unsigned short __b,
8759  vector bool short __c) {
8760  return (__a & ~(vector unsigned short)__c) |
8761  (__b & (vector unsigned short)__c);
8762 }
8763 
8764 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
8765  vector bool short __a, vector bool short __b, vector unsigned short __c) {
8766  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
8767 }
8768 
8769 static __inline__ vector bool short __ATTRS_o_ai
8770 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
8771  return (__a & ~__c) | (__b & __c);
8772 }
8773 
8774 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
8775  vector int __b,
8776  vector unsigned int __c) {
8777  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8778 }
8779 
8780 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
8781  vector int __b,
8782  vector bool int __c) {
8783  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8784 }
8785 
8786 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8787  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8788  return (__a & ~__c) | (__b & __c);
8789 }
8790 
8791 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8792  vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8793  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8794 }
8795 
8796 static __inline__ vector bool int __ATTRS_o_ai
8797 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8798  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8799 }
8800 
8801 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
8802  vector bool int __b,
8803  vector bool int __c) {
8804  return (__a & ~__c) | (__b & __c);
8805 }
8806 
8807 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8808  vector float __b,
8809  vector unsigned int __c) {
8810  vector int __res = ((vector int)__a & ~(vector int)__c) |
8811  ((vector int)__b & (vector int)__c);
8812  return (vector float)__res;
8813 }
8814 
8815 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8816  vector float __b,
8817  vector bool int __c) {
8818  vector int __res = ((vector int)__a & ~(vector int)__c) |
8819  ((vector int)__b & (vector int)__c);
8820  return (vector float)__res;
8821 }
8822 
8823 /* vec_sl */
8824 
8825 // vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8826 // than the length of __a.
8827 static __inline__ vector unsigned char __ATTRS_o_ai
8828 vec_sl(vector unsigned char __a, vector unsigned char __b) {
8829  return __a << (__b %
8830  (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8831 }
8832 
8833 static __inline__ vector signed char __ATTRS_o_ai
8834 vec_sl(vector signed char __a, vector unsigned char __b) {
8835  return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8836 }
8837 
8838 static __inline__ vector unsigned short __ATTRS_o_ai
8839 vec_sl(vector unsigned short __a, vector unsigned short __b) {
8840  return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
8841  __CHAR_BIT__));
8842 }
8843 
8844 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8845  vector unsigned short __b) {
8846  return (vector short)vec_sl((vector unsigned short)__a, __b);
8847 }
8848 
8849 static __inline__ vector unsigned int __ATTRS_o_ai
8850 vec_sl(vector unsigned int __a, vector unsigned int __b) {
8851  return __a << (__b %
8852  (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8853 }
8854 
8855 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8856  vector unsigned int __b) {
8857  return (vector int)vec_sl((vector unsigned int)__a, __b);
8858 }
8859 
8860 #ifdef __POWER8_VECTOR__
8861 static __inline__ vector unsigned long long __ATTRS_o_ai
8862 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8863  return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
8864  __CHAR_BIT__));
8865 }
8866 
8867 static __inline__ vector long long __ATTRS_o_ai
8868 vec_sl(vector long long __a, vector unsigned long long __b) {
8869  return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8870 }
8871 #elif defined(__VSX__)
8872 static __inline__ vector unsigned char __ATTRS_o_ai
8873 vec_vspltb(vector unsigned char __a, unsigned char __b);
8874 static __inline__ vector unsigned long long __ATTRS_o_ai
8875 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8876  __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
8877 
8878  // Big endian element one (the right doubleword) can be left shifted as-is.
8879  // The other element needs to be swapped into the right doubleword and
8880  // shifted. Then the right doublewords of the two result vectors are merged.
8881  vector signed long long __rightelt =
8882  (vector signed long long)__builtin_altivec_vslo((vector signed int)__a,
8883  (vector signed int)__b);
8884 #ifdef __LITTLE_ENDIAN__
8885  __rightelt = (vector signed long long)__builtin_altivec_vsl(
8886  (vector signed int)__rightelt,
8887  (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
8888 #else
8889  __rightelt = (vector signed long long)__builtin_altivec_vsl(
8890  (vector signed int)__rightelt,
8891  (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
8892 #endif
8893  __a = __builtin_shufflevector(__a, __a, 1, 0);
8894  __b = __builtin_shufflevector(__b, __b, 1, 0);
8895  vector signed long long __leftelt =
8896  (vector signed long long)__builtin_altivec_vslo((vector signed int)__a,
8897  (vector signed int)__b);
8898 #ifdef __LITTLE_ENDIAN__
8899  __leftelt = (vector signed long long)__builtin_altivec_vsl(
8900  (vector signed int)__leftelt,
8901  (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
8902  return (vector unsigned long long)__builtin_shufflevector(__rightelt,
8903  __leftelt, 0, 2);
8904 #else
8905  __leftelt = (vector signed long long)__builtin_altivec_vsl(
8906  (vector signed int)__leftelt,
8907  (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
8908  return (vector unsigned long long)__builtin_shufflevector(__leftelt,
8909  __rightelt, 1, 3);
8910 #endif
8911 }
8912 
8913 static __inline__ vector long long __ATTRS_o_ai
8914 vec_sl(vector long long __a, vector unsigned long long __b) {
8915  return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8916 }
8917 #endif /* __VSX__ */
8918 
8919 /* vec_vslb */
8920 
8921 #define __builtin_altivec_vslb vec_vslb
8922 
8923 static __inline__ vector signed char __ATTRS_o_ai
8924 vec_vslb(vector signed char __a, vector unsigned char __b) {
8925  return vec_sl(__a, __b);
8926 }
8927 
8928 static __inline__ vector unsigned char __ATTRS_o_ai
8929 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
8930  return vec_sl(__a, __b);
8931 }
8932 
8933 /* vec_vslh */
8934 
8935 #define __builtin_altivec_vslh vec_vslh
8936 
8937 static __inline__ vector short __ATTRS_o_ai
8938 vec_vslh(vector short __a, vector unsigned short __b) {
8939  return vec_sl(__a, __b);
8940 }
8941 
8942 static __inline__ vector unsigned short __ATTRS_o_ai
8943 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
8944  return vec_sl(__a, __b);
8945 }
8946 
8947 /* vec_vslw */
8948 
8949 #define __builtin_altivec_vslw vec_vslw
8950 
8951 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
8952  vector unsigned int __b) {
8953  return vec_sl(__a, __b);
8954 }
8955 
8956 static __inline__ vector unsigned int __ATTRS_o_ai
8957 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
8958  return vec_sl(__a, __b);
8959 }
8960 
8961 /* vec_sld */
8962 
8963 #define __builtin_altivec_vsldoi_4si vec_sld
8964 
8965 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
8966  vector signed char __a, vector signed char __b, unsigned const int __c) {
8967  unsigned char __d = __c & 0x0F;
8968 #ifdef __LITTLE_ENDIAN__
8969  return vec_perm(
8970  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8971  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8972  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8973  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8974 #else
8975  return vec_perm(
8976  __a, __b,
8977  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8978  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8979  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8980 #endif
8981 }
8982 
8983 static __inline__ vector unsigned char __ATTRS_o_ai
8984 vec_sld(vector unsigned char __a, vector unsigned char __b,
8985  unsigned const int __c) {
8986  unsigned char __d = __c & 0x0F;
8987 #ifdef __LITTLE_ENDIAN__
8988  return vec_perm(
8989  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8990  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8991  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8992  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8993 #else
8994  return vec_perm(
8995  __a, __b,
8996  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8997  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8998  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8999 #endif
9000 }
9001 
9002 static __inline__ vector bool char __ATTRS_o_ai
9003 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
9004  unsigned char __d = __c & 0x0F;
9005 #ifdef __LITTLE_ENDIAN__
9006  return vec_perm(
9007  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9008  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9009  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9010  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9011 #else
9012  return vec_perm(
9013  __a, __b,
9014  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9015  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9016  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9017 #endif
9018 }
9019 
9020 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
9021  vector signed short __a, vector signed short __b, unsigned const int __c) {
9022  unsigned char __d = __c & 0x0F;
9023 #ifdef __LITTLE_ENDIAN__
9024  return vec_perm(
9025  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9026  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9027  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9028  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9029 #else
9030  return vec_perm(
9031  __a, __b,
9032  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9033  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9034  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9035 #endif
9036 }
9037 
9038 static __inline__ vector unsigned short __ATTRS_o_ai
9039 vec_sld(vector unsigned short __a, vector unsigned short __b,
9040  unsigned const int __c) {
9041  unsigned char __d = __c & 0x0F;
9042 #ifdef __LITTLE_ENDIAN__
9043  return vec_perm(
9044  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9045  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9046  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9047  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9048 #else
9049  return vec_perm(
9050  __a, __b,
9051  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9052  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9053  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9054 #endif
9055 }
9056 
9057 static __inline__ vector bool short __ATTRS_o_ai
9058 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
9059  unsigned char __d = __c & 0x0F;
9060 #ifdef __LITTLE_ENDIAN__
9061  return vec_perm(
9062  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9063  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9064  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9065  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9066 #else
9067  return vec_perm(
9068  __a, __b,
9069  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9070  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9071  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9072 #endif
9073 }
9074 
9075 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
9076  vector pixel __b,
9077  unsigned const int __c) {
9078  unsigned char __d = __c & 0x0F;
9079 #ifdef __LITTLE_ENDIAN__
9080  return vec_perm(
9081  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9082  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9083  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9084  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9085 #else
9086  return vec_perm(
9087  __a, __b,
9088  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9089  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9090  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9091 #endif
9092 }
9093 
9094 static __inline__ vector signed int __ATTRS_o_ai
9095 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
9096  unsigned char __d = __c & 0x0F;
9097 #ifdef __LITTLE_ENDIAN__
9098  return vec_perm(
9099  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9100  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9101  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9102  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9103 #else
9104  return vec_perm(
9105  __a, __b,
9106  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9107  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9108  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9109 #endif
9110 }
9111 
9112 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
9113  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
9114  unsigned char __d = __c & 0x0F;
9115 #ifdef __LITTLE_ENDIAN__
9116  return vec_perm(
9117  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9118  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9119  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9120  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9121 #else
9122  return vec_perm(
9123  __a, __b,
9124  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9125  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9126  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9127 #endif
9128 }
9129 
9130 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
9131  vector bool int __b,
9132  unsigned const int __c) {
9133  unsigned char __d = __c & 0x0F;
9134 #ifdef __LITTLE_ENDIAN__
9135  return vec_perm(
9136  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9137  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9138  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9139  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9140 #else
9141  return vec_perm(
9142  __a, __b,
9143  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9144  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9145  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9146 #endif
9147 }
9148 
9149 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
9150  vector float __b,
9151  unsigned const int __c) {
9152  unsigned char __d = __c & 0x0F;
9153 #ifdef __LITTLE_ENDIAN__
9154  return vec_perm(
9155  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9156  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9157  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9158  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9159 #else
9160  return vec_perm(
9161  __a, __b,
9162  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9163  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9164  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9165 #endif
9166 }
9167 
9168 #ifdef __VSX__
9169 static __inline__ vector bool long long __ATTRS_o_ai
9170 vec_sld(vector bool long long __a, vector bool long long __b,
9171  unsigned const int __c) {
9172  unsigned char __d = __c & 0x0F;
9173 #ifdef __LITTLE_ENDIAN__
9174  return vec_perm(
9175  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9176  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9177  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9178  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9179 #else
9180  return vec_perm(
9181  __a, __b,
9182  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9183  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9184  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9185 #endif
9186 }
9187 
9188 static __inline__ vector signed long long __ATTRS_o_ai
9189 vec_sld(vector signed long long __a, vector signed long long __b,
9190  unsigned const int __c) {
9191  unsigned char __d = __c & 0x0F;
9192 #ifdef __LITTLE_ENDIAN__
9193  return vec_perm(
9194  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9195  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9196  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9197  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9198 #else
9199  return vec_perm(
9200  __a, __b,
9201  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9202  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9203  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9204 #endif
9205 }
9206 
9207 static __inline__ vector unsigned long long __ATTRS_o_ai
9208 vec_sld(vector unsigned long long __a, vector unsigned long long __b,
9209  unsigned const int __c) {
9210  unsigned char __d = __c & 0x0F;
9211 #ifdef __LITTLE_ENDIAN__
9212  return vec_perm(
9213  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9214  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9215  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9216  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9217 #else
9218  return vec_perm(
9219  __a, __b,
9220  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9221  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9222  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9223 #endif
9224 }
9225 
9226 static __inline__ vector double __ATTRS_o_ai vec_sld(vector double __a,
9227  vector double __b,
9228  unsigned const int __c) {
9229  unsigned char __d = __c & 0x0F;
9230 #ifdef __LITTLE_ENDIAN__
9231  return vec_perm(
9232  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9233  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9234  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9235  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9236 #else
9237  return vec_perm(
9238  __a, __b,
9239  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9240  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9241  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9242 #endif
9243 }
9244 #endif
9245 
9246 /* vec_sldw */
9247 static __inline__ vector signed char __ATTRS_o_ai vec_sldw(
9248  vector signed char __a, vector signed char __b, unsigned const int __c) {
9249  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9250 }
9251 
9252 static __inline__ vector unsigned char __ATTRS_o_ai
9253 vec_sldw(vector unsigned char __a, vector unsigned char __b,
9254  unsigned const int __c) {
9255  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9256 }
9257 
9258 static __inline__ vector signed short __ATTRS_o_ai vec_sldw(
9259  vector signed short __a, vector signed short __b, unsigned const int __c) {
9260  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9261 }
9262 
9263 static __inline__ vector unsigned short __ATTRS_o_ai
9264 vec_sldw(vector unsigned short __a, vector unsigned short __b,
9265  unsigned const int __c) {
9266  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9267 }
9268 
9269 static __inline__ vector signed int __ATTRS_o_ai
9270 vec_sldw(vector signed int __a, vector signed int __b, unsigned const int __c) {
9271  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9272 }
9273 
9274 static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
9275  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
9276  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9277 }
9278 
9279 static __inline__ vector float __ATTRS_o_ai vec_sldw(
9280  vector float __a, vector float __b, unsigned const int __c) {
9281  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9282 }
9283 
9284 #ifdef __VSX__
9285 static __inline__ vector signed long long __ATTRS_o_ai
9286 vec_sldw(vector signed long long __a, vector signed long long __b,
9287  unsigned const int __c) {
9288  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9289 }
9290 
9291 static __inline__ vector unsigned long long __ATTRS_o_ai
9292 vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
9293  unsigned const int __c) {
9294  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9295 }
9296 
9297 static __inline__ vector double __ATTRS_o_ai vec_sldw(
9298  vector double __a, vector double __b, unsigned const int __c) {
9299  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9300 }
9301 #endif
9302 
9303 #ifdef __POWER9_VECTOR__
9304 /* vec_slv */
9305 static __inline__ vector unsigned char __ATTRS_o_ai
9306 vec_slv(vector unsigned char __a, vector unsigned char __b) {
9307  return __builtin_altivec_vslv(__a, __b);
9308 }
9309 
9310 /* vec_srv */
9311 static __inline__ vector unsigned char __ATTRS_o_ai
9312 vec_srv(vector unsigned char __a, vector unsigned char __b) {
9313  return __builtin_altivec_vsrv(__a, __b);
9314 }
9315 #endif
9316 
9317 /* vec_vsldoi */
9318 
9319 static __inline__ vector signed char __ATTRS_o_ai
9320 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
9321  unsigned char __d = __c & 0x0F;
9322 #ifdef __LITTLE_ENDIAN__
9323  return vec_perm(
9324  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9325  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9326  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9327  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9328 #else
9329  return vec_perm(
9330  __a, __b,
9331  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9332  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9333  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9334 #endif
9335 }
9336 
9337 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
9338  vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
9339  unsigned char __d = __c & 0x0F;
9340 #ifdef __LITTLE_ENDIAN__
9341  return vec_perm(
9342  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9343  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9344  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9345  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9346 #else
9347  return vec_perm(
9348  __a, __b,
9349  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9350  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9351  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9352 #endif
9353 }
9354 
9355 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
9356  vector short __b,
9357  unsigned char __c) {
9358  unsigned char __d = __c & 0x0F;
9359 #ifdef __LITTLE_ENDIAN__
9360  return vec_perm(
9361  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9362  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9363  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9364  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9365 #else
9366  return vec_perm(
9367  __a, __b,
9368  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9369  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9370  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9371 #endif
9372 }
9373 
9374 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
9375  vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
9376  unsigned char __d = __c & 0x0F;
9377 #ifdef __LITTLE_ENDIAN__
9378  return vec_perm(
9379  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9380  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9381  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9382  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9383 #else
9384  return vec_perm(
9385  __a, __b,
9386  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9387  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9388  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9389 #endif
9390 }
9391 
9392 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
9393  vector pixel __b,
9394  unsigned char __c) {
9395  unsigned char __d = __c & 0x0F;
9396 #ifdef __LITTLE_ENDIAN__
9397  return vec_perm(
9398  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9399  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9400  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9401  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9402 #else
9403  return vec_perm(
9404  __a, __b,
9405  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9406  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9407  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9408 #endif
9409 }
9410 
9411 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
9412  vector int __b,
9413  unsigned char __c) {
9414  unsigned char __d = __c & 0x0F;
9415 #ifdef __LITTLE_ENDIAN__
9416  return vec_perm(
9417  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9418  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9419  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9420  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9421 #else
9422  return vec_perm(
9423  __a, __b,
9424  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9425  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9426  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9427 #endif
9428 }
9429 
9430 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
9431  vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
9432  unsigned char __d = __c & 0x0F;
9433 #ifdef __LITTLE_ENDIAN__
9434  return vec_perm(
9435  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9436  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9437  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9438  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9439 #else
9440  return vec_perm(
9441  __a, __b,
9442  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9443  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9444  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9445 #endif
9446 }
9447 
9448 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
9449  vector float __b,
9450  unsigned char __c) {
9451  unsigned char __d = __c & 0x0F;
9452 #ifdef __LITTLE_ENDIAN__
9453  return vec_perm(
9454  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9455  20 - __d, 21 - __d, 22 - __d, 23 - __d,
9456  24 - __d, 25 - __d, 26 - __d, 27 - __d,
9457  28 - __d, 29 - __d, 30 - __d, 31 - __d));
9458 #else
9459  return vec_perm(
9460  __a, __b,
9461  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9462  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9463  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9464 #endif
9465 }
9466 
9467 /* vec_sll */
9468 
9469 static __inline__ vector signed char __ATTRS_o_ai
9470 vec_sll(vector signed char __a, vector unsigned char __b) {
9471  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9472  (vector int)__b);
9473 }
9474 
9475 static __inline__ vector signed char __ATTRS_o_ai
9476 vec_sll(vector signed char __a, vector unsigned short __b) {
9477  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9478  (vector int)__b);
9479 }
9480 
9481 static __inline__ vector signed char __ATTRS_o_ai
9482 vec_sll(vector signed char __a, vector unsigned int __b) {
9483  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9484  (vector int)__b);
9485 }
9486 
9487 static __inline__ vector unsigned char __ATTRS_o_ai
9488 vec_sll(vector unsigned char __a, vector unsigned char __b) {
9489  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9490  (vector int)__b);
9491 }
9492 
9493 static __inline__ vector unsigned char __ATTRS_o_ai
9494 vec_sll(vector unsigned char __a, vector unsigned short __b) {
9495  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9496  (vector int)__b);
9497 }
9498 
9499 static __inline__ vector unsigned char __ATTRS_o_ai
9500 vec_sll(vector unsigned char __a, vector unsigned int __b) {
9501  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9502  (vector int)__b);
9503 }
9504 
9505 static __inline__ vector bool char __ATTRS_o_ai
9506 vec_sll(vector bool char __a, vector unsigned char __b) {
9507  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9508  (vector int)__b);
9509 }
9510 
9511 static __inline__ vector bool char __ATTRS_o_ai
9512 vec_sll(vector bool char __a, vector unsigned short __b) {
9513  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9514  (vector int)__b);
9515 }
9516 
9517 static __inline__ vector bool char __ATTRS_o_ai
9518 vec_sll(vector bool char __a, vector unsigned int __b) {
9519  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9520  (vector int)__b);
9521 }
9522 
9523 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9524  vector unsigned char __b) {
9525  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9526 }
9527 
9528 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9529  vector unsigned short __b) {
9530  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9531 }
9532 
9533 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9534  vector unsigned int __b) {
9535  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9536 }
9537 
9538 static __inline__ vector unsigned short __ATTRS_o_ai
9539 vec_sll(vector unsigned short __a, vector unsigned char __b) {
9540  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9541  (vector int)__b);
9542 }
9543 
9544 static __inline__ vector unsigned short __ATTRS_o_ai
9545 vec_sll(vector unsigned short __a, vector unsigned short __b) {
9546  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9547  (vector int)__b);
9548 }
9549 
9550 static __inline__ vector unsigned short __ATTRS_o_ai
9551 vec_sll(vector unsigned short __a, vector unsigned int __b) {
9552  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9553  (vector int)__b);
9554 }
9555 
9556 static __inline__ vector bool short __ATTRS_o_ai
9557 vec_sll(vector bool short __a, vector unsigned char __b) {
9558  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9559  (vector int)__b);
9560 }
9561 
9562 static __inline__ vector bool short __ATTRS_o_ai
9563 vec_sll(vector bool short __a, vector unsigned short __b) {
9564  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9565  (vector int)__b);
9566 }
9567 
9568 static __inline__ vector bool short __ATTRS_o_ai
9569 vec_sll(vector bool short __a, vector unsigned int __b) {
9570  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9571  (vector int)__b);
9572 }
9573 
9574 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9575  vector unsigned char __b) {
9576  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9577 }
9578 
9579 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9580  vector unsigned short __b) {
9581  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9582 }
9583 
9584 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9585  vector unsigned int __b) {
9586  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9587 }
9588 
9589 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9590  vector unsigned char __b) {
9591  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9592 }
9593 
9594 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9595  vector unsigned short __b) {
9596  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9597 }
9598 
9599 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9600  vector unsigned int __b) {
9601  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9602 }
9603 
9604 static __inline__ vector unsigned int __ATTRS_o_ai
9605 vec_sll(vector unsigned int __a, vector unsigned char __b) {
9606  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9607  (vector int)__b);
9608 }
9609 
9610 static __inline__ vector unsigned int __ATTRS_o_ai
9611 vec_sll(vector unsigned int __a, vector unsigned short __b) {
9612  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9613  (vector int)__b);
9614 }
9615 
9616 static __inline__ vector unsigned int __ATTRS_o_ai
9617 vec_sll(vector unsigned int __a, vector unsigned int __b) {
9618  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9619  (vector int)__b);
9620 }
9621 
9622 static __inline__ vector bool int __ATTRS_o_ai
9623 vec_sll(vector bool int __a, vector unsigned char __b) {
9624  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9625  (vector int)__b);
9626 }
9627 
9628 static __inline__ vector bool int __ATTRS_o_ai
9629 vec_sll(vector bool int __a, vector unsigned short __b) {
9630  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9631  (vector int)__b);
9632 }
9633 
9634 static __inline__ vector bool int __ATTRS_o_ai
9635 vec_sll(vector bool int __a, vector unsigned int __b) {
9636  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9637  (vector int)__b);
9638 }
9639 
9640 #ifdef __VSX__
9641 static __inline__ vector signed long long __ATTRS_o_ai
9642 vec_sll(vector signed long long __a, vector unsigned char __b) {
9643  return (vector signed long long)__builtin_altivec_vsl((vector int)__a,
9644  (vector int)__b);
9645 }
9646 
9647 static __inline__ vector unsigned long long __ATTRS_o_ai
9648 vec_sll(vector unsigned long long __a, vector unsigned char __b) {
9649  return (vector unsigned long long)__builtin_altivec_vsl((vector int)__a,
9650  (vector int)__b);
9651 }
9652 #endif
9653 
9654 /* vec_vsl */
9655 
9656 static __inline__ vector signed char __ATTRS_o_ai
9657 vec_vsl(vector signed char __a, vector unsigned char __b) {
9658  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9659  (vector int)__b);
9660 }
9661 
9662 static __inline__ vector signed char __ATTRS_o_ai
9663 vec_vsl(vector signed char __a, vector unsigned short __b) {
9664  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9665  (vector int)__b);
9666 }
9667 
9668 static __inline__ vector signed char __ATTRS_o_ai
9669 vec_vsl(vector signed char __a, vector unsigned int __b) {
9670  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9671  (vector int)__b);
9672 }
9673 
9674 static __inline__ vector unsigned char __ATTRS_o_ai
9675 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
9676  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9677  (vector int)__b);
9678 }
9679 
9680 static __inline__ vector unsigned char __ATTRS_o_ai
9681 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
9682  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9683  (vector int)__b);
9684 }
9685 
9686 static __inline__ vector unsigned char __ATTRS_o_ai
9687 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
9688  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9689  (vector int)__b);
9690 }
9691 
9692 static __inline__ vector bool char __ATTRS_o_ai
9693 vec_vsl(vector bool char __a, vector unsigned char __b) {
9694  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9695  (vector int)__b);
9696 }
9697 
9698 static __inline__ vector bool char __ATTRS_o_ai
9699 vec_vsl(vector bool char __a, vector unsigned short __b) {
9700  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9701  (vector int)__b);
9702 }
9703 
9704 static __inline__ vector bool char __ATTRS_o_ai
9705 vec_vsl(vector bool char __a, vector unsigned int __b) {
9706  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9707  (vector int)__b);
9708 }
9709 
9710 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9711  vector unsigned char __b) {
9712  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9713 }
9714 
9715 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9716  vector unsigned short __b) {
9717  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9718 }
9719 
9720 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9721  vector unsigned int __b) {
9722  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9723 }
9724 
9725 static __inline__ vector unsigned short __ATTRS_o_ai
9726 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
9727  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9728  (vector int)__b);
9729 }
9730 
9731 static __inline__ vector unsigned short __ATTRS_o_ai
9732 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
9733  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9734  (vector int)__b);
9735 }
9736 
9737 static __inline__ vector unsigned short __ATTRS_o_ai
9738 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
9739  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9740  (vector int)__b);
9741 }
9742 
9743 static __inline__ vector bool short __ATTRS_o_ai
9744 vec_vsl(vector bool short __a, vector unsigned char __b) {
9745  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9746  (vector int)__b);
9747 }
9748 
9749 static __inline__ vector bool short __ATTRS_o_ai
9750 vec_vsl(vector bool short __a, vector unsigned short __b) {
9751  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9752  (vector int)__b);
9753 }
9754 
9755 static __inline__ vector bool short __ATTRS_o_ai
9756 vec_vsl(vector bool short __a, vector unsigned int __b) {
9757  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9758  (vector int)__b);
9759 }
9760 
9761 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9762  vector unsigned char __b) {
9763  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9764 }
9765 
9766 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9767  vector unsigned short __b) {
9768  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9769 }
9770 
9771 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9772  vector unsigned int __b) {
9773  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9774 }
9775 
9776 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9777  vector unsigned char __b) {
9778  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9779 }
9780 
9781 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9782  vector unsigned short __b) {
9783  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9784 }
9785 
9786 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9787  vector unsigned int __b) {
9788  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9789 }
9790 
9791 static __inline__ vector unsigned int __ATTRS_o_ai
9792 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
9793  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9794  (vector int)__b);
9795 }
9796 
9797 static __inline__ vector unsigned int __ATTRS_o_ai
9798 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
9799  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9800  (vector int)__b);
9801 }
9802 
9803 static __inline__ vector unsigned int __ATTRS_o_ai
9804 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
9805  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9806  (vector int)__b);
9807 }
9808 
9809 static __inline__ vector bool int __ATTRS_o_ai
9810 vec_vsl(vector bool int __a, vector unsigned char __b) {
9811  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9812  (vector int)__b);
9813 }
9814 
9815 static __inline__ vector bool int __ATTRS_o_ai
9816 vec_vsl(vector bool int __a, vector unsigned short __b) {
9817  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9818  (vector int)__b);
9819 }
9820 
9821 static __inline__ vector bool int __ATTRS_o_ai
9822 vec_vsl(vector bool int __a, vector unsigned int __b) {
9823  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9824  (vector int)__b);
9825 }
9826 
9827 /* vec_slo */
9828 
9829 static __inline__ vector signed char __ATTRS_o_ai
9830 vec_slo(vector signed char __a, vector signed char __b) {
9831  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9832  (vector int)__b);
9833 }
9834 
9835 static __inline__ vector signed char __ATTRS_o_ai
9836 vec_slo(vector signed char __a, vector unsigned char __b) {
9837  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9838  (vector int)__b);
9839 }
9840 
9841 static __inline__ vector unsigned char __ATTRS_o_ai
9842 vec_slo(vector unsigned char __a, vector signed char __b) {
9843  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9844  (vector int)__b);
9845 }
9846 
9847 static __inline__ vector unsigned char __ATTRS_o_ai
9848 vec_slo(vector unsigned char __a, vector unsigned char __b) {
9849  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9850  (vector int)__b);
9851 }
9852 
9853 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9854  vector signed char __b) {
9855  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9856 }
9857 
9858 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9859  vector unsigned char __b) {
9860  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9861 }
9862 
9863 static __inline__ vector unsigned short __ATTRS_o_ai
9864 vec_slo(vector unsigned short __a, vector signed char __b) {
9865  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9866  (vector int)__b);
9867 }
9868 
9869 static __inline__ vector unsigned short __ATTRS_o_ai
9870 vec_slo(vector unsigned short __a, vector unsigned char __b) {
9871  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9872  (vector int)__b);
9873 }
9874 
9875 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9876  vector signed char __b) {
9877  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9878 }
9879 
9880 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9881  vector unsigned char __b) {
9882  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9883 }
9884 
9885 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9886  vector signed char __b) {
9887  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9888 }
9889 
9890 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9891  vector unsigned char __b) {
9892  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9893 }
9894 
9895 static __inline__ vector unsigned int __ATTRS_o_ai
9896 vec_slo(vector unsigned int __a, vector signed char __b) {
9897  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9898  (vector int)__b);
9899 }
9900 
9901 static __inline__ vector unsigned int __ATTRS_o_ai
9902 vec_slo(vector unsigned int __a, vector unsigned char __b) {
9903  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9904  (vector int)__b);
9905 }
9906 
9907 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9908  vector signed char __b) {
9909  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9910 }
9911 
9912 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9913  vector unsigned char __b) {
9914  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9915 }
9916 
9917 #ifdef __VSX__
9918 static __inline__ vector signed long long __ATTRS_o_ai
9919 vec_slo(vector signed long long __a, vector signed char __b) {
9920  return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9921  (vector int)__b);
9922 }
9923 
9924 static __inline__ vector signed long long __ATTRS_o_ai
9925 vec_slo(vector signed long long __a, vector unsigned char __b) {
9926  return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9927  (vector int)__b);
9928 }
9929 
9930 static __inline__ vector unsigned long long __ATTRS_o_ai
9931 vec_slo(vector unsigned long long __a, vector signed char __b) {
9932  return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9933  (vector int)__b);
9934 }
9935 
9936 static __inline__ vector unsigned long long __ATTRS_o_ai
9937 vec_slo(vector unsigned long long __a, vector unsigned char __b) {
9938  return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9939  (vector int)__b);
9940 }
9941 #endif
9942 
9943 /* vec_vslo */
9944 
9945 static __inline__ vector signed char __ATTRS_o_ai
9946 vec_vslo(vector signed char __a, vector signed char __b) {
9947  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9948  (vector int)__b);
9949 }
9950 
9951 static __inline__ vector signed char __ATTRS_o_ai
9952 vec_vslo(vector signed char __a, vector unsigned char __b) {
9953  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9954  (vector int)__b);
9955 }
9956 
9957 static __inline__ vector unsigned char __ATTRS_o_ai
9958 vec_vslo(vector unsigned char __a, vector signed char __b) {
9959  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9960  (vector int)__b);
9961 }
9962 
9963 static __inline__ vector unsigned char __ATTRS_o_ai
9964 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
9965  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9966  (vector int)__b);
9967 }
9968 
9969 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9970  vector signed char __b) {
9971  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9972 }
9973 
9974 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9975  vector unsigned char __b) {
9976  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9977 }
9978 
9979 static __inline__ vector unsigned short __ATTRS_o_ai
9980 vec_vslo(vector unsigned short __a, vector signed char __b) {
9981  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9982  (vector int)__b);
9983 }
9984 
9985 static __inline__ vector unsigned short __ATTRS_o_ai
9986 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
9987  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9988  (vector int)__b);
9989 }
9990 
9991 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9992  vector signed char __b) {
9993  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9994 }
9995 
9996 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9997  vector unsigned char __b) {
9998  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9999 }
10000 
10001 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
10002  vector signed char __b) {
10003  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
10004 }
10005 
10006 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
10007  vector unsigned char __b) {
10008  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
10009 }
10010 
10011 static __inline__ vector unsigned int __ATTRS_o_ai
10012 vec_vslo(vector unsigned int __a, vector signed char __b) {
10013  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
10014  (vector int)__b);
10015 }
10016 
10017 static __inline__ vector unsigned int __ATTRS_o_ai
10018 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
10019  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
10020  (vector int)__b);
10021 }
10022 
10023 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
10024  vector signed char __b) {
10025  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10026 }
10027 
10028 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
10029  vector unsigned char __b) {
10030  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10031 }
10032 
10033 /* vec_splat */
10034 
10035 static __inline__ vector signed char __ATTRS_o_ai
10036 vec_splat(vector signed char __a, unsigned const int __b) {
10037  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10038 }
10039 
10040 static __inline__ vector unsigned char __ATTRS_o_ai
10041 vec_splat(vector unsigned char __a, unsigned const int __b) {
10042  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10043 }
10044 
10045 static __inline__ vector bool char __ATTRS_o_ai
10046 vec_splat(vector bool char __a, unsigned const int __b) {
10047  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10048 }
10049 
10050 static __inline__ vector signed short __ATTRS_o_ai
10051 vec_splat(vector signed short __a, unsigned const int __b) {
10052  unsigned char b0 = (__b & 0x07) * 2;
10053  unsigned char b1 = b0 + 1;
10054  return vec_perm(__a, __a,
10055  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10056  b0, b1, b0, b1, b0, b1));
10057 }
10058 
10059 static __inline__ vector unsigned short __ATTRS_o_ai
10060 vec_splat(vector unsigned short __a, unsigned const int __b) {
10061  unsigned char b0 = (__b & 0x07) * 2;
10062  unsigned char b1 = b0 + 1;
10063  return vec_perm(__a, __a,
10064  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10065  b0, b1, b0, b1, b0, b1));
10066 }
10067 
10068 static __inline__ vector bool short __ATTRS_o_ai
10069 vec_splat(vector bool short __a, unsigned const int __b) {
10070  unsigned char b0 = (__b & 0x07) * 2;
10071  unsigned char b1 = b0 + 1;
10072  return vec_perm(__a, __a,
10073  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10074  b0, b1, b0, b1, b0, b1));
10075 }
10076 
10077 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
10078  unsigned const int __b) {
10079  unsigned char b0 = (__b & 0x07) * 2;
10080  unsigned char b1 = b0 + 1;
10081  return vec_perm(__a, __a,
10082  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10083  b0, b1, b0, b1, b0, b1));
10084 }
10085 
10086 static __inline__ vector signed int __ATTRS_o_ai
10087 vec_splat(vector signed int __a, unsigned const int __b) {
10088  unsigned char b0 = (__b & 0x03) * 4;
10089  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10090  return vec_perm(__a, __a,
10091  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10092  b2, b3, b0, b1, b2, b3));
10093 }
10094 
10095 static __inline__ vector unsigned int __ATTRS_o_ai
10096 vec_splat(vector unsigned int __a, unsigned const int __b) {
10097  unsigned char b0 = (__b & 0x03) * 4;
10098  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10099  return vec_perm(__a, __a,
10100  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10101  b2, b3, b0, b1, b2, b3));
10102 }
10103 
10104 static __inline__ vector bool int __ATTRS_o_ai
10105 vec_splat(vector bool int __a, unsigned const int __b) {
10106  unsigned char b0 = (__b & 0x03) * 4;
10107  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10108  return vec_perm(__a, __a,
10109  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10110  b2, b3, b0, b1, b2, b3));
10111 }
10112 
10113 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
10114  unsigned const int __b) {
10115  unsigned char b0 = (__b & 0x03) * 4;
10116  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10117  return vec_perm(__a, __a,
10118  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10119  b2, b3, b0, b1, b2, b3));
10120 }
10121 
10122 #ifdef __VSX__
10123 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
10124  unsigned const int __b) {
10125  unsigned char b0 = (__b & 0x01) * 8;
10126  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10127  b6 = b0 + 6, b7 = b0 + 7;
10128  return vec_perm(__a, __a,
10129  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10130  b2, b3, b4, b5, b6, b7));
10131 }
10132 static __inline__ vector bool long long __ATTRS_o_ai
10133 vec_splat(vector bool long long __a, unsigned const int __b) {
10134  unsigned char b0 = (__b & 0x01) * 8;
10135  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10136  b6 = b0 + 6, b7 = b0 + 7;
10137  return vec_perm(__a, __a,
10138  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10139  b2, b3, b4, b5, b6, b7));
10140 }
10141 static __inline__ vector signed long long __ATTRS_o_ai
10142 vec_splat(vector signed long long __a, unsigned const int __b) {
10143  unsigned char b0 = (__b & 0x01) * 8;
10144  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10145  b6 = b0 + 6, b7 = b0 + 7;
10146  return vec_perm(__a, __a,
10147  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10148  b2, b3, b4, b5, b6, b7));
10149 }
10150 static __inline__ vector unsigned long long __ATTRS_o_ai
10151 vec_splat(vector unsigned long long __a, unsigned const int __b) {
10152  unsigned char b0 = (__b & 0x01) * 8;
10153  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10154  b6 = b0 + 6, b7 = b0 + 7;
10155  return vec_perm(__a, __a,
10156  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10157  b2, b3, b4, b5, b6, b7));
10158 }
10159 #endif
10160 
10161 /* vec_vspltb */
10162 
10163 #define __builtin_altivec_vspltb vec_vspltb
10164 
10165 static __inline__ vector signed char __ATTRS_o_ai
10166 vec_vspltb(vector signed char __a, unsigned char __b) {
10167  return vec_perm(__a, __a, (vector unsigned char)(__b));
10168 }
10169 
10170 static __inline__ vector unsigned char __ATTRS_o_ai
10171 vec_vspltb(vector unsigned char __a, unsigned char __b) {
10172  return vec_perm(__a, __a, (vector unsigned char)(__b));
10173 }
10174 
10175 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
10176  unsigned char __b) {
10177  return vec_perm(__a, __a, (vector unsigned char)(__b));
10178 }
10179 
10180 /* vec_vsplth */
10181 
10182 #define __builtin_altivec_vsplth vec_vsplth
10183 
10184 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
10185  unsigned char __b) {
10186  __b *= 2;
10187  unsigned char b1 = __b + 1;
10188  return vec_perm(__a, __a,
10189  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10190  __b, b1, __b, b1, __b, b1, __b, b1));
10191 }
10192 
10193 static __inline__ vector unsigned short __ATTRS_o_ai
10194 vec_vsplth(vector unsigned short __a, unsigned char __b) {
10195  __b *= 2;
10196  unsigned char b1 = __b + 1;
10197  return vec_perm(__a, __a,
10198  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10199  __b, b1, __b, b1, __b, b1, __b, b1));
10200 }
10201 
10202 static __inline__ vector bool short __ATTRS_o_ai
10203 vec_vsplth(vector bool short __a, unsigned char __b) {
10204  __b *= 2;
10205  unsigned char b1 = __b + 1;
10206  return vec_perm(__a, __a,
10207  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10208  __b, b1, __b, b1, __b, b1, __b, b1));
10209 }
10210 
10211 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
10212  unsigned char __b) {
10213  __b *= 2;
10214  unsigned char b1 = __b + 1;
10215  return vec_perm(__a, __a,
10216  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10217  __b, b1, __b, b1, __b, b1, __b, b1));
10218 }
10219 
10220 /* vec_vspltw */
10221 
10222 #define __builtin_altivec_vspltw vec_vspltw
10223 
10224 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
10225  unsigned char __b) {
10226  __b *= 4;
10227  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10228  return vec_perm(__a, __a,
10229  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10230  b1, b2, b3, __b, b1, b2, b3));
10231 }
10232 
10233 static __inline__ vector unsigned int __ATTRS_o_ai
10234 vec_vspltw(vector unsigned int __a, unsigned char __b) {
10235  __b *= 4;
10236  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10237  return vec_perm(__a, __a,
10238  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10239  b1, b2, b3, __b, b1, b2, b3));
10240 }
10241 
10242 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
10243  unsigned char __b) {
10244  __b *= 4;
10245  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10246  return vec_perm(__a, __a,
10247  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10248  b1, b2, b3, __b, b1, b2, b3));
10249 }
10250 
10251 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
10252  unsigned char __b) {
10253  __b *= 4;
10254  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10255  return vec_perm(__a, __a,
10256  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10257  b1, b2, b3, __b, b1, b2, b3));
10258 }
10259 
10260 /* vec_splat_s8 */
10261 
10262 #define __builtin_altivec_vspltisb vec_splat_s8
10263 
10264 // FIXME: parameter should be treated as 5-bit signed literal
10265 static __inline__ vector signed char __ATTRS_o_ai
10266 vec_splat_s8(signed char __a) {
10267  return (vector signed char)(__a);
10268 }
10269 
10270 /* vec_vspltisb */
10271 
10272 // FIXME: parameter should be treated as 5-bit signed literal
10273 static __inline__ vector signed char __ATTRS_o_ai
10274 vec_vspltisb(signed char __a) {
10275  return (vector signed char)(__a);
10276 }
10277 
10278 /* vec_splat_s16 */
10279 
10280 #define __builtin_altivec_vspltish vec_splat_s16
10281 
10282 // FIXME: parameter should be treated as 5-bit signed literal
10283 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
10284  return (vector short)(__a);
10285 }
10286 
10287 /* vec_vspltish */
10288 
10289 // FIXME: parameter should be treated as 5-bit signed literal
10290 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
10291  return (vector short)(__a);
10292 }
10293 
10294 /* vec_splat_s32 */
10295 
10296 #define __builtin_altivec_vspltisw vec_splat_s32
10297 
10298 // FIXME: parameter should be treated as 5-bit signed literal
10299 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
10300  return (vector int)(__a);
10301 }
10302 
10303 /* vec_vspltisw */
10304 
10305 // FIXME: parameter should be treated as 5-bit signed literal
10306 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
10307  return (vector int)(__a);
10308 }
10309 
10310 /* vec_splat_u8 */
10311 
10312 // FIXME: parameter should be treated as 5-bit signed literal
10313 static __inline__ vector unsigned char __ATTRS_o_ai
10314 vec_splat_u8(unsigned char __a) {
10315  return (vector unsigned char)(__a);
10316 }
10317 
10318 /* vec_splat_u16 */
10319 
10320 // FIXME: parameter should be treated as 5-bit signed literal
10321 static __inline__ vector unsigned short __ATTRS_o_ai
10322 vec_splat_u16(signed char __a) {
10323  return (vector unsigned short)(__a);
10324 }
10325 
10326 /* vec_splat_u32 */
10327 
10328 // FIXME: parameter should be treated as 5-bit signed literal
10329 static __inline__ vector unsigned int __ATTRS_o_ai
10330 vec_splat_u32(signed char __a) {
10331  return (vector unsigned int)(__a);
10332 }
10333 
10334 /* vec_sr */
10335 
10336 // vec_sr does modulo arithmetic on __b first, so __b is allowed to be more
10337 // than the length of __a.
10338 static __inline__ vector unsigned char __ATTRS_o_ai
10339 vec_sr(vector unsigned char __a, vector unsigned char __b) {
10340  return __a >>
10341  (__b % (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
10342 }
10343 
10344 static __inline__ vector signed char __ATTRS_o_ai
10345 vec_sr(vector signed char __a, vector unsigned char __b) {
10346  return (vector signed char)vec_sr((vector unsigned char)__a, __b);
10347 }
10348 
10349 static __inline__ vector unsigned short __ATTRS_o_ai
10350 vec_sr(vector unsigned short __a, vector unsigned short __b) {
10351  return __a >>
10352  (__b % (vector unsigned short)(sizeof(unsigned short) * __CHAR_BIT__));
10353 }
10354 
10355 static __inline__ vector short __ATTRS_o_ai vec_sr(vector short __a,
10356  vector unsigned short __b) {
10357  return (vector short)vec_sr((vector unsigned short)__a, __b);
10358 }
10359 
10360 static __inline__ vector unsigned int __ATTRS_o_ai
10361 vec_sr(vector unsigned int __a, vector unsigned int __b) {
10362  return __a >>
10363  (__b % (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
10364 }
10365 
10366 static __inline__ vector int __ATTRS_o_ai vec_sr(vector int __a,
10367  vector unsigned int __b) {
10368  return (vector int)vec_sr((vector unsigned int)__a, __b);
10369 }
10370 
10371 #ifdef __POWER8_VECTOR__
10372 static __inline__ vector unsigned long long __ATTRS_o_ai
10373 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
10374  return __a >> (__b % (vector unsigned long long)(sizeof(unsigned long long) *
10375  __CHAR_BIT__));
10376 }
10377 
10378 static __inline__ vector long long __ATTRS_o_ai
10379 vec_sr(vector long long __a, vector unsigned long long __b) {
10380  return (vector long long)vec_sr((vector unsigned long long)__a, __b);
10381 }
10382 #elif defined(__VSX__)
10383 static __inline__ vector unsigned long long __ATTRS_o_ai
10384 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
10385  __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10386 
10387  // Big endian element zero (the left doubleword) can be right shifted as-is.
10388  // However the shift amount must be in the right doubleword.
10389  // The other element needs to be swapped into the left doubleword and
10390  // shifted. Then the left doublewords of the two result vectors are merged.
10391  vector unsigned long long __swapshift =
10392  __builtin_shufflevector(__b, __b, 1, 0);
10393  vector unsigned long long __leftelt =
10394  (vector unsigned long long)__builtin_altivec_vsro(
10395  (vector signed int)__a, (vector signed int)__swapshift);
10396 #ifdef __LITTLE_ENDIAN__
10397  __leftelt = (vector unsigned long long)__builtin_altivec_vsr(
10398  (vector signed int)__leftelt,
10399  (vector signed int)vec_vspltb((vector unsigned char)__swapshift, 0));
10400 #else
10401  __leftelt = (vector unsigned long long)__builtin_altivec_vsr(
10402  (vector signed int)__leftelt,
10403  (vector signed int)vec_vspltb((vector unsigned char)__swapshift, 15));
10404 #endif
10405  __a = __builtin_shufflevector(__a, __a, 1, 0);
10406  vector unsigned long long __rightelt =
10407  (vector unsigned long long)__builtin_altivec_vsro((vector signed int)__a,
10408  (vector signed int)__b);
10409 #ifdef __LITTLE_ENDIAN__
10410  __rightelt = (vector unsigned long long)__builtin_altivec_vsr(
10411  (vector signed int)__rightelt,
10412  (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
10413  return __builtin_shufflevector(__rightelt, __leftelt, 1, 3);
10414 #else
10415  __rightelt = (vector unsigned long long)__builtin_altivec_vsr(
10416  (vector signed int)__rightelt,
10417  (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
10418  return __builtin_shufflevector(__leftelt, __rightelt, 0, 2);
10419 #endif
10420 }
10421 
10422 static __inline__ vector long long __ATTRS_o_ai
10423 vec_sr(vector long long __a, vector unsigned long long __b) {
10424  return (vector long long)vec_sr((vector unsigned long long)__a, __b);
10425 }
10426 #endif /* __VSX__ */
10427 
10428 /* vec_vsrb */
10429 
10430 #define __builtin_altivec_vsrb vec_vsrb
10431 
10432 static __inline__ vector signed char __ATTRS_o_ai
10433 vec_vsrb(vector signed char __a, vector unsigned char __b) {
10434  return vec_sr(__a, __b);
10435 }
10436 
10437 static __inline__ vector unsigned char __ATTRS_o_ai
10438 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
10439  return vec_sr(__a, __b);
10440 }
10441 
10442 /* vec_vsrh */
10443 
10444 #define __builtin_altivec_vsrh vec_vsrh
10445 
10446 static __inline__ vector short __ATTRS_o_ai
10447 vec_vsrh(vector short __a, vector unsigned short __b) {
10448  return vec_sr(__a, __b);
10449 }
10450 
10451 static __inline__ vector unsigned short __ATTRS_o_ai
10452 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
10453  return vec_sr(__a, __b);
10454 }
10455 
10456 /* vec_vsrw */
10457 
10458 #define __builtin_altivec_vsrw vec_vsrw
10459 
10460 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
10461  vector unsigned int __b) {
10462  return vec_sr(__a, __b);
10463 }
10464 
10465 static __inline__ vector unsigned int __ATTRS_o_ai
10466 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
10467  return vec_sr(__a, __b);
10468 }
10469 
10470 /* vec_sra */
10471 
10472 static __inline__ vector signed char __ATTRS_o_ai
10473 vec_sra(vector signed char __a, vector unsigned char __b) {
10474  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
10475 }
10476 
10477 static __inline__ vector unsigned char __ATTRS_o_ai
10478 vec_sra(vector unsigned char __a, vector unsigned char __b) {
10479  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
10480 }
10481 
10482 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
10483  vector unsigned short __b) {
10484  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
10485 }
10486 
10487 static __inline__ vector unsigned short __ATTRS_o_ai
10488 vec_sra(vector unsigned short __a, vector unsigned short __b) {
10489  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
10490 }
10491 
10492 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
10493  vector unsigned int __b) {
10494  return __builtin_altivec_vsraw(__a, __b);
10495 }
10496 
10497 static __inline__ vector unsigned int __ATTRS_o_ai
10498 vec_sra(vector unsigned int __a, vector unsigned int __b) {
10499  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
10500 }
10501 
10502 #ifdef __POWER8_VECTOR__
10503 static __inline__ vector signed long long __ATTRS_o_ai
10504 vec_sra(vector signed long long __a, vector unsigned long long __b) {
10505  return __a >> __b;
10506 }
10507 
10508 static __inline__ vector unsigned long long __ATTRS_o_ai
10509 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
10510  return (vector unsigned long long)((vector signed long long)__a >> __b);
10511 }
10512 #elif defined(__VSX__)
10513 static __inline__ vector signed long long __ATTRS_o_ai
10514 vec_sra(vector signed long long __a, vector unsigned long long __b) {
10515  __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10516  return __a >> __b;
10517 }
10518 
10519 static __inline__ vector unsigned long long __ATTRS_o_ai
10520 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
10521  __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10522  return (vector unsigned long long)((vector signed long long)__a >> __b);
10523 }
10524 #endif /* __VSX__ */
10525 
10526 /* vec_vsrab */
10527 
10528 static __inline__ vector signed char __ATTRS_o_ai
10529 vec_vsrab(vector signed char __a, vector unsigned char __b) {
10530  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
10531 }
10532 
10533 static __inline__ vector unsigned char __ATTRS_o_ai
10534 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
10535  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
10536 }
10537 
10538 /* vec_vsrah */
10539 
10540 static __inline__ vector short __ATTRS_o_ai
10541 vec_vsrah(vector short __a, vector unsigned short __b) {
10542  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
10543 }
10544 
10545 static __inline__ vector unsigned short __ATTRS_o_ai
10546 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
10547  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
10548 }
10549 
10550 /* vec_vsraw */
10551 
10552 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
10553  vector unsigned int __b) {
10554  return __builtin_altivec_vsraw(__a, __b);
10555 }
10556 
10557 static __inline__ vector unsigned int __ATTRS_o_ai
10558 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
10559  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
10560 }
10561 
10562 /* vec_srl */
10563 
10564 static __inline__ vector signed char __ATTRS_o_ai
10565 vec_srl(vector signed char __a, vector unsigned char __b) {
10566  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10567  (vector int)__b);
10568 }
10569 
10570 static __inline__ vector signed char __ATTRS_o_ai
10571 vec_srl(vector signed char __a, vector unsigned short __b) {
10572  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10573  (vector int)__b);
10574 }
10575 
10576 static __inline__ vector signed char __ATTRS_o_ai
10577 vec_srl(vector signed char __a, vector unsigned int __b) {
10578  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10579  (vector int)__b);
10580 }
10581 
10582 static __inline__ vector unsigned char __ATTRS_o_ai
10583 vec_srl(vector unsigned char __a, vector unsigned char __b) {
10584  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10585  (vector int)__b);
10586 }
10587 
10588 static __inline__ vector unsigned char __ATTRS_o_ai
10589 vec_srl(vector unsigned char __a, vector unsigned short __b) {
10590  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10591  (vector int)__b);
10592 }
10593 
10594 static __inline__ vector unsigned char __ATTRS_o_ai
10595 vec_srl(vector unsigned char __a, vector unsigned int __b) {
10596  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10597  (vector int)__b);
10598 }
10599 
10600 static __inline__ vector bool char __ATTRS_o_ai
10601 vec_srl(vector bool char __a, vector unsigned char __b) {
10602  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10603  (vector int)__b);
10604 }
10605 
10606 static __inline__ vector bool char __ATTRS_o_ai
10607 vec_srl(vector bool char __a, vector unsigned short __b) {
10608  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10609  (vector int)__b);
10610 }
10611 
10612 static __inline__ vector bool char __ATTRS_o_ai
10613 vec_srl(vector bool char __a, vector unsigned int __b) {
10614  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10615  (vector int)__b);
10616 }
10617 
10618 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10619  vector unsigned char __b) {
10620  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10621 }
10622 
10623 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10624  vector unsigned short __b) {
10625  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10626 }
10627 
10628 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10629  vector unsigned int __b) {
10630  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10631 }
10632 
10633 static __inline__ vector unsigned short __ATTRS_o_ai
10634 vec_srl(vector unsigned short __a, vector unsigned char __b) {
10635  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10636  (vector int)__b);
10637 }
10638 
10639 static __inline__ vector unsigned short __ATTRS_o_ai
10640 vec_srl(vector unsigned short __a, vector unsigned short __b) {
10641  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10642  (vector int)__b);
10643 }
10644 
10645 static __inline__ vector unsigned short __ATTRS_o_ai
10646 vec_srl(vector unsigned short __a, vector unsigned int __b) {
10647  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10648  (vector int)__b);
10649 }
10650 
10651 static __inline__ vector bool short __ATTRS_o_ai
10652 vec_srl(vector bool short __a, vector unsigned char __b) {
10653  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10654  (vector int)__b);
10655 }
10656 
10657 static __inline__ vector bool short __ATTRS_o_ai
10658 vec_srl(vector bool short __a, vector unsigned short __b) {
10659  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10660  (vector int)__b);
10661 }
10662 
10663 static __inline__ vector bool short __ATTRS_o_ai
10664 vec_srl(vector bool short __a, vector unsigned int __b) {
10665  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10666  (vector int)__b);
10667 }
10668 
10669 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10670  vector unsigned char __b) {
10671  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10672 }
10673 
10674 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10675  vector unsigned short __b) {
10676  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10677 }
10678 
10679 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10680  vector unsigned int __b) {
10681  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10682 }
10683 
10684 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10685  vector unsigned char __b) {
10686  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10687 }
10688 
10689 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10690  vector unsigned short __b) {
10691  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10692 }
10693 
10694 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10695  vector unsigned int __b) {
10696  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10697 }
10698 
10699 static __inline__ vector unsigned int __ATTRS_o_ai
10700 vec_srl(vector unsigned int __a, vector unsigned char __b) {
10701  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10702  (vector int)__b);
10703 }
10704 
10705 static __inline__ vector unsigned int __ATTRS_o_ai
10706 vec_srl(vector unsigned int __a, vector unsigned short __b) {
10707  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10708  (vector int)__b);
10709 }
10710 
10711 static __inline__ vector unsigned int __ATTRS_o_ai
10712 vec_srl(vector unsigned int __a, vector unsigned int __b) {
10713  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10714  (vector int)__b);
10715 }
10716 
10717 static __inline__ vector bool int __ATTRS_o_ai
10718 vec_srl(vector bool int __a, vector unsigned char __b) {
10719  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10720  (vector int)__b);
10721 }
10722 
10723 static __inline__ vector bool int __ATTRS_o_ai
10724 vec_srl(vector bool int __a, vector unsigned short __b) {
10725  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10726  (vector int)__b);
10727 }
10728 
10729 static __inline__ vector bool int __ATTRS_o_ai
10730 vec_srl(vector bool int __a, vector unsigned int __b) {
10731  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10732  (vector int)__b);
10733 }
10734 
10735 #ifdef __VSX__
10736 static __inline__ vector signed long long __ATTRS_o_ai
10737 vec_srl(vector signed long long __a, vector unsigned char __b) {
10738  return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
10739  (vector int)__b);
10740 }
10741 
10742 static __inline__ vector unsigned long long __ATTRS_o_ai
10743 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
10744  return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
10745  (vector int)__b);
10746 }
10747 #endif
10748 
10749 /* vec_vsr */
10750 
10751 static __inline__ vector signed char __ATTRS_o_ai
10752 vec_vsr(vector signed char __a, vector unsigned char __b) {
10753  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10754  (vector int)__b);
10755 }
10756 
10757 static __inline__ vector signed char __ATTRS_o_ai
10758 vec_vsr(vector signed char __a, vector unsigned short __b) {
10759  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10760  (vector int)__b);
10761 }
10762 
10763 static __inline__ vector signed char __ATTRS_o_ai
10764 vec_vsr(vector signed char __a, vector unsigned int __b) {
10765  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10766  (vector int)__b);
10767 }
10768 
10769 static __inline__ vector unsigned char __ATTRS_o_ai
10770 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
10771  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10772  (vector int)__b);
10773 }
10774 
10775 static __inline__ vector unsigned char __ATTRS_o_ai
10776 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
10777  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10778  (vector int)__b);
10779 }
10780 
10781 static __inline__ vector unsigned char __ATTRS_o_ai
10782 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
10783  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10784  (vector int)__b);
10785 }
10786 
10787 static __inline__ vector bool char __ATTRS_o_ai
10788 vec_vsr(vector bool char __a, vector unsigned char __b) {
10789  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10790  (vector int)__b);
10791 }
10792 
10793 static __inline__ vector bool char __ATTRS_o_ai
10794 vec_vsr(vector bool char __a, vector unsigned short __b) {
10795  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10796  (vector int)__b);
10797 }
10798 
10799 static __inline__ vector bool char __ATTRS_o_ai
10800 vec_vsr(vector bool char __a, vector unsigned int __b) {
10801  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10802  (vector int)__b);
10803 }
10804 
10805 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10806  vector unsigned char __b) {
10807  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10808 }
10809 
10810 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10811  vector unsigned short __b) {
10812  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10813 }
10814 
10815 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10816  vector unsigned int __b) {
10817  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10818 }
10819 
10820 static __inline__ vector unsigned short __ATTRS_o_ai
10821 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
10822  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10823  (vector int)__b);
10824 }
10825 
10826 static __inline__ vector unsigned short __ATTRS_o_ai
10827 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
10828  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10829  (vector int)__b);
10830 }
10831 
10832 static __inline__ vector unsigned short __ATTRS_o_ai
10833 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
10834  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10835  (vector int)__b);
10836 }
10837 
10838 static __inline__ vector bool short __ATTRS_o_ai
10839 vec_vsr(vector bool short __a, vector unsigned char __b) {
10840  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10841  (vector int)__b);
10842 }
10843 
10844 static __inline__ vector bool short __ATTRS_o_ai
10845 vec_vsr(vector bool short __a, vector unsigned short __b) {
10846  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10847  (vector int)__b);
10848 }
10849 
10850 static __inline__ vector bool short __ATTRS_o_ai
10851 vec_vsr(vector bool short __a, vector unsigned int __b) {
10852  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10853  (vector int)__b);
10854 }
10855 
10856 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10857  vector unsigned char __b) {
10858  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10859 }
10860 
10861 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10862  vector unsigned short __b) {
10863  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10864 }
10865 
10866 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10867  vector unsigned int __b) {
10868  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10869 }
10870 
10871 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10872  vector unsigned char __b) {
10873  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10874 }
10875 
10876 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10877  vector unsigned short __b) {
10878  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10879 }
10880 
10881 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10882  vector unsigned int __b) {
10883  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10884 }
10885 
10886 static __inline__ vector unsigned int __ATTRS_o_ai
10887 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
10888  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10889  (vector int)__b);
10890 }
10891 
10892 static __inline__ vector unsigned int __ATTRS_o_ai
10893 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
10894  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10895  (vector int)__b);
10896 }
10897 
10898 static __inline__ vector unsigned int __ATTRS_o_ai
10899 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
10900  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10901  (vector int)__b);
10902 }
10903 
10904 static __inline__ vector bool int __ATTRS_o_ai
10905 vec_vsr(vector bool int __a, vector unsigned char __b) {
10906  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10907  (vector int)__b);
10908 }
10909 
10910 static __inline__ vector bool int __ATTRS_o_ai
10911 vec_vsr(vector bool int __a, vector unsigned short __b) {
10912  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10913  (vector int)__b);
10914 }
10915 
10916 static __inline__ vector bool int __ATTRS_o_ai
10917 vec_vsr(vector bool int __a, vector unsigned int __b) {
10918  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10919  (vector int)__b);
10920 }
10921 
10922 /* vec_sro */
10923 
10924 static __inline__ vector signed char __ATTRS_o_ai
10925 vec_sro(vector signed char __a, vector signed char __b) {
10926  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10927  (vector int)__b);
10928 }
10929 
10930 static __inline__ vector signed char __ATTRS_o_ai
10931 vec_sro(vector signed char __a, vector unsigned char __b) {
10932  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10933  (vector int)__b);
10934 }
10935 
10936 static __inline__ vector unsigned char __ATTRS_o_ai
10937 vec_sro(vector unsigned char __a, vector signed char __b) {
10938  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10939  (vector int)__b);
10940 }
10941 
10942 static __inline__ vector unsigned char __ATTRS_o_ai
10943 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10944  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10945  (vector int)__b);
10946 }
10947 
10948 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10949  vector signed char __b) {
10950  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10951 }
10952 
10953 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10954  vector unsigned char __b) {
10955  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10956 }
10957 
10958 static __inline__ vector unsigned short __ATTRS_o_ai
10959 vec_sro(vector unsigned short __a, vector signed char __b) {
10960  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10961  (vector int)__b);
10962 }
10963 
10964 static __inline__ vector unsigned short __ATTRS_o_ai
10965 vec_sro(vector unsigned short __a, vector unsigned char __b) {
10966  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10967  (vector int)__b);
10968 }
10969 
10970 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10971  vector signed char __b) {
10972  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10973 }
10974 
10975 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10976  vector unsigned char __b) {
10977  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10978 }
10979 
10980 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10981  vector signed char __b) {
10982  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10983 }
10984 
10985 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10986  vector unsigned char __b) {
10987  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10988 }
10989 
10990 static __inline__ vector unsigned int __ATTRS_o_ai
10991 vec_sro(vector unsigned int __a, vector signed char __b) {
10992  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10993  (vector int)__b);
10994 }
10995 
10996 static __inline__ vector unsigned int __ATTRS_o_ai
10997 vec_sro(vector unsigned int __a, vector unsigned char __b) {
10998  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10999  (vector int)__b);
11000 }
11001 
11002 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
11003  vector signed char __b) {
11004  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11005 }
11006 
11007 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
11008  vector unsigned char __b) {
11009  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11010 }
11011 
11012 #ifdef __VSX__
11013 static __inline__ vector signed long long __ATTRS_o_ai
11014 vec_sro(vector signed long long __a, vector signed char __b) {
11015  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
11016  (vector int)__b);
11017 }
11018 
11019 static __inline__ vector signed long long __ATTRS_o_ai
11020 vec_sro(vector signed long long __a, vector unsigned char __b) {
11021  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
11022  (vector int)__b);
11023 }
11024 
11025 static __inline__ vector unsigned long long __ATTRS_o_ai
11026 vec_sro(vector unsigned long long __a, vector signed char __b) {
11027  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
11028  (vector int)__b);
11029 }
11030 
11031 static __inline__ vector unsigned long long __ATTRS_o_ai
11032 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
11033  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
11034  (vector int)__b);
11035 }
11036 #endif
11037 
11038 /* vec_vsro */
11039 
11040 static __inline__ vector signed char __ATTRS_o_ai
11041 vec_vsro(vector signed char __a, vector signed char __b) {
11042  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
11043  (vector int)__b);
11044 }
11045 
11046 static __inline__ vector signed char __ATTRS_o_ai
11047 vec_vsro(vector signed char __a, vector unsigned char __b) {
11048  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
11049  (vector int)__b);
11050 }
11051 
11052 static __inline__ vector unsigned char __ATTRS_o_ai
11053 vec_vsro(vector unsigned char __a, vector signed char __b) {
11054  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
11055  (vector int)__b);
11056 }
11057 
11058 static __inline__ vector unsigned char __ATTRS_o_ai
11059 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
11060  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
11061  (vector int)__b);
11062 }
11063 
11064 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
11065  vector signed char __b) {
11066  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11067 }
11068 
11069 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
11070  vector unsigned char __b) {
11071  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11072 }
11073 
11074 static __inline__ vector unsigned short __ATTRS_o_ai
11075 vec_vsro(vector unsigned short __a, vector signed char __b) {
11076  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11077  (vector int)__b);
11078 }
11079 
11080 static __inline__ vector unsigned short __ATTRS_o_ai
11081 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
11082  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11083  (vector int)__b);
11084 }
11085 
11086 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
11087  vector signed char __b) {
11088  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11089 }
11090 
11091 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
11092  vector unsigned char __b) {
11093  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11094 }
11095 
11096 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
11097  vector signed char __b) {
11098  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11099 }
11100 
11101 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
11102  vector unsigned char __b) {
11103  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11104 }
11105 
11106 static __inline__ vector unsigned int __ATTRS_o_ai
11107 vec_vsro(vector unsigned int __a, vector signed char __b) {
11108  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11109  (vector int)__b);
11110 }
11111 
11112 static __inline__ vector unsigned int __ATTRS_o_ai
11113 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
11114  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11115  (vector int)__b);
11116 }
11117 
11118 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
11119  vector signed char __b) {
11120  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11121 }
11122 
11123 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
11124  vector unsigned char __b) {
11125  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11126 }
11127 
11128 /* vec_st */
11129 
11130 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
11131  vector signed char *__c) {
11132  __builtin_altivec_stvx((vector int)__a, __b, __c);
11133 }
11134 
11135 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
11136  signed char *__c) {
11137  __builtin_altivec_stvx((vector int)__a, __b, __c);
11138 }
11139 
11140 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
11141  vector unsigned char *__c) {
11142  __builtin_altivec_stvx((vector int)__a, __b, __c);
11143 }
11144 
11145 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
11146  unsigned char *__c) {
11147  __builtin_altivec_stvx((vector int)__a, __b, __c);
11148 }
11149 
11150 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11151  signed char *__c) {
11152  __builtin_altivec_stvx((vector int)__a, __b, __c);
11153 }
11154 
11155 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11156  unsigned char *__c) {
11157  __builtin_altivec_stvx((vector int)__a, __b, __c);
11158 }
11159 
11160 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11161  vector bool char *__c) {
11162  __builtin_altivec_stvx((vector int)__a, __b, __c);
11163 }
11164 
11165 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
11166  vector short *__c) {
11167  __builtin_altivec_stvx((vector int)__a, __b, __c);
11168 }
11169 
11170 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
11171  short *__c) {
11172  __builtin_altivec_stvx((vector int)__a, __b, __c);
11173 }
11174 
11175 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
11176  vector unsigned short *__c) {
11177  __builtin_altivec_stvx((vector int)__a, __b, __c);
11178 }
11179 
11180 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
11181  unsigned short *__c) {
11182  __builtin_altivec_stvx((vector int)__a, __b, __c);
11183 }
11184 
11185 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11186  short *__c) {
11187  __builtin_altivec_stvx((vector int)__a, __b, __c);
11188 }
11189 
11190 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11191  unsigned short *__c) {
11192  __builtin_altivec_stvx((vector int)__a, __b, __c);
11193 }
11194 
11195 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11196  vector bool short *__c) {
11197  __builtin_altivec_stvx((vector int)__a, __b, __c);
11198 }
11199 
11200 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11201  short *__c) {
11202  __builtin_altivec_stvx((vector int)__a, __b, __c);
11203 }
11204 
11205 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11206  unsigned short *__c) {
11207  __builtin_altivec_stvx((vector int)__a, __b, __c);
11208 }
11209 
11210 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11211  vector pixel *__c) {
11212  __builtin_altivec_stvx((vector int)__a, __b, __c);
11213 }
11214 
11215 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b,
11216  vector int *__c) {
11217  __builtin_altivec_stvx(__a, __b, __c);
11218 }
11219 
11220 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b, int *__c) {
11221  __builtin_altivec_stvx(__a, __b, __c);
11222 }
11223 
11224 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
11225  vector unsigned int *__c) {
11226  __builtin_altivec_stvx((vector int)__a, __b, __c);
11227 }
11228 
11229 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
11230  unsigned int *__c) {
11231  __builtin_altivec_stvx((vector int)__a, __b, __c);
11232 }
11233 
11234 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11235  int *__c) {
11236  __builtin_altivec_stvx((vector int)__a, __b, __c);
11237 }
11238 
11239 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11240  unsigned int *__c) {
11241  __builtin_altivec_stvx((vector int)__a, __b, __c);
11242 }
11243 
11244 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11245  vector bool int *__c) {
11246  __builtin_altivec_stvx((vector int)__a, __b, __c);
11247 }
11248 
11249 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
11250  vector float *__c) {
11251  __builtin_altivec_stvx((vector int)__a, __b, __c);
11252 }
11253 
11254 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
11255  float *__c) {
11256  __builtin_altivec_stvx((vector int)__a, __b, __c);
11257 }
11258 
11259 /* vec_stvx */
11260 
11261 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
11262  vector signed char *__c) {
11263  __builtin_altivec_stvx((vector int)__a, __b, __c);
11264 }
11265 
11266 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
11267  signed char *__c) {
11268  __builtin_altivec_stvx((vector int)__a, __b, __c);
11269 }
11270 
11271 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
11272  vector unsigned char *__c) {
11273  __builtin_altivec_stvx((vector int)__a, __b, __c);
11274 }
11275 
11276 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
11277  unsigned char *__c) {
11278  __builtin_altivec_stvx((vector int)__a, __b, __c);
11279 }
11280 
11281 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11282  signed char *__c) {
11283  __builtin_altivec_stvx((vector int)__a, __b, __c);
11284 }
11285 
11286 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11287  unsigned char *__c) {
11288  __builtin_altivec_stvx((vector int)__a, __b, __c);
11289 }
11290 
11291 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11292  vector bool char *__c) {
11293  __builtin_altivec_stvx((vector int)__a, __b, __c);
11294 }
11295 
11296 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
11297  vector short *__c) {
11298  __builtin_altivec_stvx((vector int)__a, __b, __c);
11299 }
11300 
11301 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
11302  short *__c) {
11303  __builtin_altivec_stvx((vector int)__a, __b, __c);
11304 }
11305 
11306 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
11307  vector unsigned short *__c) {
11308  __builtin_altivec_stvx((vector int)__a, __b, __c);
11309 }
11310 
11311 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
11312  unsigned short *__c) {
11313  __builtin_altivec_stvx((vector int)__a, __b, __c);
11314 }
11315 
11316 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11317  short *__c) {
11318  __builtin_altivec_stvx((vector int)__a, __b, __c);
11319 }
11320 
11321 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11322  unsigned short *__c) {
11323  __builtin_altivec_stvx((vector int)__a, __b, __c);
11324 }
11325 
11326 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11327  vector bool short *__c) {
11328  __builtin_altivec_stvx((vector int)__a, __b, __c);
11329 }
11330 
11331 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11332  short *__c) {
11333  __builtin_altivec_stvx((vector int)__a, __b, __c);
11334 }
11335 
11336 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11337  unsigned short *__c) {
11338  __builtin_altivec_stvx((vector int)__a, __b, __c);
11339 }
11340 
11341 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11342  vector pixel *__c) {
11343  __builtin_altivec_stvx((vector int)__a, __b, __c);
11344 }
11345 
11346 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
11347  vector int *__c) {
11348  __builtin_altivec_stvx(__a, __b, __c);
11349 }
11350 
11351 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
11352  int *__c) {
11353  __builtin_altivec_stvx(__a, __b, __c);
11354 }
11355 
11356 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
11357  vector unsigned int *__c) {
11358  __builtin_altivec_stvx((vector int)__a, __b, __c);
11359 }
11360 
11361 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
11362  unsigned int *__c) {
11363  __builtin_altivec_stvx((vector int)__a, __b, __c);
11364 }
11365 
11366 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11367  int *__c) {
11368  __builtin_altivec_stvx((vector int)__a, __b, __c);
11369 }
11370 
11371 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11372  unsigned int *__c) {
11373  __builtin_altivec_stvx((vector int)__a, __b, __c);
11374 }
11375 
11376 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11377  vector bool int *__c) {
11378  __builtin_altivec_stvx((vector int)__a, __b, __c);
11379 }
11380 
11381 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
11382  vector float *__c) {
11383  __builtin_altivec_stvx((vector int)__a, __b, __c);
11384 }
11385 
11386 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
11387  float *__c) {
11388  __builtin_altivec_stvx((vector int)__a, __b, __c);
11389 }
11390 
11391 /* vec_ste */
11392 
11393 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, long __b,
11394  signed char *__c) {
11395  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11396 }
11397 
11398 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, long __b,
11399  unsigned char *__c) {
11400  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11401 }
11402 
11403 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
11404  signed char *__c) {
11405  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11406 }
11407 
11408 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
11409  unsigned char *__c) {
11410  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11411 }
11412 
11413 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, long __b,
11414  short *__c) {
11415  __builtin_altivec_stvehx(__a, __b, __c);
11416 }
11417 
11418 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, long __b,
11419  unsigned short *__c) {
11420  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11421 }
11422 
11423 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
11424  short *__c) {
11425  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11426 }
11427 
11428 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
11429  unsigned short *__c) {
11430  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11431 }
11432 
11433 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
11434  short *__c) {
11435  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11436 }
11437 
11438 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
11439  unsigned short *__c) {
11440  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11441 }
11442 
11443 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, long __b, int *__c) {
11444  __builtin_altivec_stvewx(__a, __b, __c);
11445 }
11446 
11447 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, long __b,
11448  unsigned int *__c) {
11449  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11450 }
11451 
11452 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
11453  int *__c) {
11454  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11455 }
11456 
11457 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
11458  unsigned int *__c) {
11459  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11460 }
11461 
11462 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, long __b,
11463  float *__c) {
11464  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11465 }
11466 
11467 /* vec_stvebx */
11468 
11469 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, long __b,
11470  signed char *__c) {
11471  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11472 }
11473 
11474 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
11475  long __b, unsigned char *__c) {
11476  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11477 }
11478 
11479 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
11480  signed char *__c) {
11481  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11482 }
11483 
11484 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
11485  unsigned char *__c) {
11486  __builtin_altivec_stvebx((vector char)__a, __b, __c);
11487 }
11488 
11489 /* vec_stvehx */
11490 
11491 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, long __b,
11492  short *__c) {
11493  __builtin_altivec_stvehx(__a, __b, __c);
11494 }
11495 
11496 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
11497  long __b, unsigned short *__c) {
11498  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11499 }
11500 
11501 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
11502  short *__c) {
11503  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11504 }
11505 
11506 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
11507  unsigned short *__c) {
11508  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11509 }
11510 
11511 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
11512  short *__c) {
11513  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11514 }
11515 
11516 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
11517  unsigned short *__c) {
11518  __builtin_altivec_stvehx((vector short)__a, __b, __c);
11519 }
11520 
11521 /* vec_stvewx */
11522 
11523 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, long __b,
11524  int *__c) {
11525  __builtin_altivec_stvewx(__a, __b, __c);
11526 }
11527 
11528 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, long __b,
11529  unsigned int *__c) {
11530  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11531 }
11532 
11533 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
11534  int *__c) {
11535  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11536 }
11537 
11538 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
11539  unsigned int *__c) {
11540  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11541 }
11542 
11543 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, long __b,
11544  float *__c) {
11545  __builtin_altivec_stvewx((vector int)__a, __b, __c);
11546 }
11547 
11548 /* vec_stl */
11549 
11550 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
11551  vector signed char *__c) {
11552  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11553 }
11554 
11555 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
11556  signed char *__c) {
11557  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11558 }
11559 
11560 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
11561  vector unsigned char *__c) {
11562  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11563 }
11564 
11565 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
11566  unsigned char *__c) {
11567  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11568 }
11569 
11570 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11571  signed char *__c) {
11572  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11573 }
11574 
11575 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11576  unsigned char *__c) {
11577  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11578 }
11579 
11580 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11581  vector bool char *__c) {
11582  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11583 }
11584 
11585 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
11586  vector short *__c) {
11587  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11588 }
11589 
11590 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
11591  short *__c) {
11592  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11593 }
11594 
11595 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
11596  vector unsigned short *__c) {
11597  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11598 }
11599 
11600 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
11601  unsigned short *__c) {
11602  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11603 }
11604 
11605 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11606  short *__c) {
11607  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11608 }
11609 
11610 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11611  unsigned short *__c) {
11612  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11613 }
11614 
11615 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11616  vector bool short *__c) {
11617  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11618 }
11619 
11620 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11621  short *__c) {
11622  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11623 }
11624 
11625 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11626  unsigned short *__c) {
11627  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11628 }
11629 
11630 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11631  vector pixel *__c) {
11632  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11633 }
11634 
11635 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
11636  vector int *__c) {
11637  __builtin_altivec_stvxl(__a, __b, __c);
11638 }
11639 
11640 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
11641  __builtin_altivec_stvxl(__a, __b, __c);
11642 }
11643 
11644 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
11645  vector unsigned int *__c) {
11646  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11647 }
11648 
11649 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
11650  unsigned int *__c) {
11651  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11652 }
11653 
11654 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11655  int *__c) {
11656  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11657 }
11658 
11659 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11660  unsigned int *__c) {
11661  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11662 }
11663 
11664 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11665  vector bool int *__c) {
11666  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11667 }
11668 
11669 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
11670  vector float *__c) {
11671  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11672 }
11673 
11674 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
11675  float *__c) {
11676  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11677 }
11678 
11679 /* vec_stvxl */
11680 
11681 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
11682  vector signed char *__c) {
11683  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11684 }
11685 
11686 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
11687  signed char *__c) {
11688  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11689 }
11690 
11691 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
11692  vector unsigned char *__c) {
11693  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11694 }
11695 
11696 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
11697  unsigned char *__c) {
11698  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11699 }
11700 
11701 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11702  signed char *__c) {
11703  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11704 }
11705 
11706 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11707  unsigned char *__c) {
11708  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11709 }
11710 
11711 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11712  vector bool char *__c) {
11713  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11714 }
11715 
11716 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
11717  vector short *__c) {
11718  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11719 }
11720 
11721 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
11722  short *__c) {
11723  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11724 }
11725 
11726 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
11727  int __b,
11728  vector unsigned short *__c) {
11729  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11730 }
11731 
11732 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
11733  int __b, unsigned short *__c) {
11734  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11735 }
11736 
11737 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11738  short *__c) {
11739  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11740 }
11741 
11742 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11743  unsigned short *__c) {
11744  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11745 }
11746 
11747 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11748  vector bool short *__c) {
11749  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11750 }
11751 
11752 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11753  short *__c) {
11754  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11755 }
11756 
11757 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11758  unsigned short *__c) {
11759  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11760 }
11761 
11762 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11763  vector pixel *__c) {
11764  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11765 }
11766 
11767 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
11768  vector int *__c) {
11769  __builtin_altivec_stvxl(__a, __b, __c);
11770 }
11771 
11772 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
11773  int *__c) {
11774  __builtin_altivec_stvxl(__a, __b, __c);
11775 }
11776 
11777 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
11778  vector unsigned int *__c) {
11779  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11780 }
11781 
11782 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
11783  unsigned int *__c) {
11784  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11785 }
11786 
11787 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11788  int *__c) {
11789  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11790 }
11791 
11792 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11793  unsigned int *__c) {
11794  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11795 }
11796 
11797 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11798  vector bool int *__c) {
11799  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11800 }
11801 
11802 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
11803  vector float *__c) {
11804  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11805 }
11806 
11807 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
11808  float *__c) {
11809  __builtin_altivec_stvxl((vector int)__a, __b, __c);
11810 }
11811 
11812 /* vec_sub */
11813 
11814 static __inline__ vector signed char __ATTRS_o_ai
11815 vec_sub(vector signed char __a, vector signed char __b) {
11816  return __a - __b;
11817 }
11818 
11819 static __inline__ vector signed char __ATTRS_o_ai
11820 vec_sub(vector bool char __a, vector signed char __b) {
11821  return (vector signed char)__a - __b;
11822 }
11823 
11824 static __inline__ vector signed char __ATTRS_o_ai
11825 vec_sub(vector signed char __a, vector bool char __b) {
11826  return __a - (vector signed char)__b;
11827 }
11828 
11829 static __inline__ vector unsigned char __ATTRS_o_ai
11830 vec_sub(vector unsigned char __a, vector unsigned char __b) {
11831  return __a - __b;
11832 }
11833 
11834 static __inline__ vector unsigned char __ATTRS_o_ai
11835 vec_sub(vector bool char __a, vector unsigned char __b) {
11836  return (vector unsigned char)__a - __b;
11837 }
11838 
11839 static __inline__ vector unsigned char __ATTRS_o_ai
11840 vec_sub(vector unsigned char __a, vector bool char __b) {
11841  return __a - (vector unsigned char)__b;
11842 }
11843 
11844 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
11845  vector short __b) {
11846  return __a - __b;
11847 }
11848 
11849 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
11850  vector short __b) {
11851  return (vector short)__a - __b;
11852 }
11853 
11854 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
11855  vector bool short __b) {
11856  return __a - (vector short)__b;
11857 }
11858 
11859 static __inline__ vector unsigned short __ATTRS_o_ai
11860 vec_sub(vector unsigned short __a, vector unsigned short __b) {
11861  return __a - __b;
11862 }
11863 
11864 static __inline__ vector unsigned short __ATTRS_o_ai
11865 vec_sub(vector bool short __a, vector unsigned short __b) {
11866  return (vector unsigned short)__a - __b;
11867 }
11868 
11869 static __inline__ vector unsigned short __ATTRS_o_ai
11870 vec_sub(vector unsigned short __a, vector bool short __b) {
11871  return __a - (vector unsigned short)__b;
11872 }
11873 
11874 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
11875  vector int __b) {
11876  return __a - __b;
11877 }
11878 
11879 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
11880  vector int __b) {
11881  return (vector int)__a - __b;
11882 }
11883 
11884 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
11885  vector bool int __b) {
11886  return __a - (vector int)__b;
11887 }
11888 
11889 static __inline__ vector unsigned int __ATTRS_o_ai
11890 vec_sub(vector unsigned int __a, vector unsigned int __b) {
11891  return __a - __b;
11892 }
11893 
11894 static __inline__ vector unsigned int __ATTRS_o_ai
11895 vec_sub(vector bool int __a, vector unsigned int __b) {
11896  return (vector unsigned int)__a - __b;
11897 }
11898 
11899 static __inline__ vector unsigned int __ATTRS_o_ai
11900 vec_sub(vector unsigned int __a, vector bool int __b) {
11901  return __a - (vector unsigned int)__b;
11902 }
11903 
11904 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
11905  defined(__SIZEOF_INT128__)
11906 static __inline__ vector signed __int128 __ATTRS_o_ai
11907 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
11908  return __a - __b;
11909 }
11910 
11911 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11912 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11913  return __a - __b;
11914 }
11915 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&
11916  // defined(__SIZEOF_INT128__)
11917 
11918 #ifdef __VSX__
11919 static __inline__ vector signed long long __ATTRS_o_ai
11920 vec_sub(vector signed long long __a, vector signed long long __b) {
11921  return __a - __b;
11922 }
11923 
11924 static __inline__ vector unsigned long long __ATTRS_o_ai
11925 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11926  return __a - __b;
11927 }
11928 
11929 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11930  vector double __b) {
11931  return __a - __b;
11932 }
11933 #endif
11934 
11935 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11936  vector float __b) {
11937  return __a - __b;
11938 }
11939 
11940 /* vec_vsububm */
11941 
11942 #define __builtin_altivec_vsububm vec_vsububm
11943 
11944 static __inline__ vector signed char __ATTRS_o_ai
11945 vec_vsububm(vector signed char __a, vector signed char __b) {
11946  return __a - __b;
11947 }
11948 
11949 static __inline__ vector signed char __ATTRS_o_ai
11950 vec_vsububm(vector bool char __a, vector signed char __b) {
11951  return (vector signed char)__a - __b;
11952 }
11953 
11954 static __inline__ vector signed char __ATTRS_o_ai
11955 vec_vsububm(vector signed char __a, vector bool char __b) {
11956  return __a - (vector signed char)__b;
11957 }
11958 
11959 static __inline__ vector unsigned char __ATTRS_o_ai
11960 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
11961  return __a - __b;
11962 }
11963 
11964 static __inline__ vector unsigned char __ATTRS_o_ai
11965 vec_vsububm(vector bool char __a, vector unsigned char __b) {
11966  return (vector unsigned char)__a - __b;
11967 }
11968 
11969 static __inline__ vector unsigned char __ATTRS_o_ai
11970 vec_vsububm(vector unsigned char __a, vector bool char __b) {
11971  return __a - (vector unsigned char)__b;
11972 }
11973 
11974 /* vec_vsubuhm */
11975 
11976 #define __builtin_altivec_vsubuhm vec_vsubuhm
11977 
11978 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11979  vector short __b) {
11980  return __a - __b;
11981 }
11982 
11983 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
11984  vector short __b) {
11985  return (vector short)__a - __b;
11986 }
11987 
11988 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11989  vector bool short __b) {
11990  return __a - (vector short)__b;
11991 }
11992 
11993 static __inline__ vector unsigned short __ATTRS_o_ai
11994 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
11995  return __a - __b;
11996 }
11997 
11998 static __inline__ vector unsigned short __ATTRS_o_ai
11999 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
12000  return (vector unsigned short)__a - __b;
12001 }
12002 
12003 static __inline__ vector unsigned short __ATTRS_o_ai
12004 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
12005  return __a - (vector unsigned short)__b;
12006 }
12007 
12008 /* vec_vsubuwm */
12009 
12010 #define __builtin_altivec_vsubuwm vec_vsubuwm
12011 
12012 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
12013  vector int __b) {
12014  return __a - __b;
12015 }
12016 
12017 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
12018  vector int __b) {
12019  return (vector int)__a - __b;
12020 }
12021 
12022 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
12023  vector bool int __b) {
12024  return __a - (vector int)__b;
12025 }
12026 
12027 static __inline__ vector unsigned int __ATTRS_o_ai
12028 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
12029  return __a - __b;
12030 }
12031 
12032 static __inline__ vector unsigned int __ATTRS_o_ai
12033 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
12034  return (vector unsigned int)__a - __b;
12035 }
12036 
12037 static __inline__ vector unsigned int __ATTRS_o_ai
12038 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
12039  return __a - (vector unsigned int)__b;
12040 }
12041 
12042 /* vec_vsubfp */
12043 
12044 #define __builtin_altivec_vsubfp vec_vsubfp
12045 
12046 static __inline__ vector float __attribute__((__always_inline__))
12047 vec_vsubfp(vector float __a, vector float __b) {
12048  return __a - __b;
12049 }
12050 
12051 /* vec_subc */
12052 
12053 static __inline__ vector signed int __ATTRS_o_ai
12054 vec_subc(vector signed int __a, vector signed int __b) {
12055  return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
12056  (vector unsigned int) __b);
12057 }
12058 
12059 static __inline__ vector unsigned int __ATTRS_o_ai
12060 vec_subc(vector unsigned int __a, vector unsigned int __b) {
12061  return __builtin_altivec_vsubcuw(__a, __b);
12062 }
12063 
12064 #ifdef __POWER8_VECTOR__
12065 #ifdef __SIZEOF_INT128__
12066 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12067 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12068  return __builtin_altivec_vsubcuq(__a, __b);
12069 }
12070 
12071 static __inline__ vector signed __int128 __ATTRS_o_ai
12072 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
12073  return __builtin_altivec_vsubcuq(__a, __b);
12074 }
12075 #endif
12076 
12077 static __inline__ vector unsigned char __attribute__((__always_inline__))
12078 vec_subc_u128(vector unsigned char __a, vector unsigned char __b) {
12079  return (vector unsigned char)__builtin_altivec_vsubcuq(__a, __b);
12080 }
12081 #endif // __POWER8_VECTOR__
12082 
12083 /* vec_vsubcuw */
12084 
12085 static __inline__ vector unsigned int __attribute__((__always_inline__))
12086 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
12087  return __builtin_altivec_vsubcuw(__a, __b);
12088 }
12089 
12090 /* vec_subs */
12091 
12092 static __inline__ vector signed char __ATTRS_o_ai
12093 vec_subs(vector signed char __a, vector signed char __b) {
12094  return __builtin_altivec_vsubsbs(__a, __b);
12095 }
12096 
12097 static __inline__ vector signed char __ATTRS_o_ai
12098 vec_subs(vector bool char __a, vector signed char __b) {
12099  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
12100 }
12101 
12102 static __inline__ vector signed char __ATTRS_o_ai
12103 vec_subs(vector signed char __a, vector bool char __b) {
12104  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
12105 }
12106 
12107 static __inline__ vector unsigned char __ATTRS_o_ai
12108 vec_subs(vector unsigned char __a, vector unsigned char __b) {
12109  return __builtin_altivec_vsububs(__a, __b);
12110 }
12111 
12112 static __inline__ vector unsigned char __ATTRS_o_ai
12113 vec_subs(vector bool char __a, vector unsigned char __b) {
12114  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
12115 }
12116 
12117 static __inline__ vector unsigned char __ATTRS_o_ai
12118 vec_subs(vector unsigned char __a, vector bool char __b) {
12119  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
12120 }
12121 
12122 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
12123  vector short __b) {
12124  return __builtin_altivec_vsubshs(__a, __b);
12125 }
12126 
12127 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
12128  vector short __b) {
12129  return __builtin_altivec_vsubshs((vector short)__a, __b);
12130 }
12131 
12132 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
12133  vector bool short __b) {
12134  return __builtin_altivec_vsubshs(__a, (vector short)__b);
12135 }
12136 
12137 static __inline__ vector unsigned short __ATTRS_o_ai
12138 vec_subs(vector unsigned short __a, vector unsigned short __b) {
12139  return __builtin_altivec_vsubuhs(__a, __b);
12140 }
12141 
12142 static __inline__ vector unsigned short __ATTRS_o_ai
12143 vec_subs(vector bool short __a, vector unsigned short __b) {
12144  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
12145 }
12146 
12147 static __inline__ vector unsigned short __ATTRS_o_ai
12148 vec_subs(vector unsigned short __a, vector bool short __b) {
12149  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
12150 }
12151 
12152 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
12153  vector int __b) {
12154  return __builtin_altivec_vsubsws(__a, __b);
12155 }
12156 
12157 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
12158  vector int __b) {
12159  return __builtin_altivec_vsubsws((vector int)__a, __b);
12160 }
12161 
12162 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
12163  vector bool int __b) {
12164  return __builtin_altivec_vsubsws(__a, (vector int)__b);
12165 }
12166 
12167 static __inline__ vector unsigned int __ATTRS_o_ai
12168 vec_subs(vector unsigned int __a, vector unsigned int __b) {
12169  return __builtin_altivec_vsubuws(__a, __b);
12170 }
12171 
12172 static __inline__ vector unsigned int __ATTRS_o_ai
12173 vec_subs(vector bool int __a, vector unsigned int __b) {
12174  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
12175 }
12176 
12177 static __inline__ vector unsigned int __ATTRS_o_ai
12178 vec_subs(vector unsigned int __a, vector bool int __b) {
12179  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
12180 }
12181 
12182 /* vec_vsubsbs */
12183 
12184 static __inline__ vector signed char __ATTRS_o_ai
12185 vec_vsubsbs(vector signed char __a, vector signed char __b) {
12186  return __builtin_altivec_vsubsbs(__a, __b);
12187 }
12188 
12189 static __inline__ vector signed char __ATTRS_o_ai
12190 vec_vsubsbs(vector bool char __a, vector signed char __b) {
12191  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
12192 }
12193 
12194 static __inline__ vector signed char __ATTRS_o_ai
12195 vec_vsubsbs(vector signed char __a, vector bool char __b) {
12196  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
12197 }
12198 
12199 /* vec_vsububs */
12200 
12201 static __inline__ vector unsigned char __ATTRS_o_ai
12202 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
12203  return __builtin_altivec_vsububs(__a, __b);
12204 }
12205 
12206 static __inline__ vector unsigned char __ATTRS_o_ai
12207 vec_vsububs(vector bool char __a, vector unsigned char __b) {
12208  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
12209 }
12210 
12211 static __inline__ vector unsigned char __ATTRS_o_ai
12212 vec_vsububs(vector unsigned char __a, vector bool char __b) {
12213  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
12214 }
12215 
12216 /* vec_vsubshs */
12217 
12218 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
12219  vector short __b) {
12220  return __builtin_altivec_vsubshs(__a, __b);
12221 }
12222 
12223 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
12224  vector short __b) {
12225  return __builtin_altivec_vsubshs((vector short)__a, __b);
12226 }
12227 
12228 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
12229  vector bool short __b) {
12230  return __builtin_altivec_vsubshs(__a, (vector short)__b);
12231 }
12232 
12233 /* vec_vsubuhs */
12234 
12235 static __inline__ vector unsigned short __ATTRS_o_ai
12236 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
12237  return __builtin_altivec_vsubuhs(__a, __b);
12238 }
12239 
12240 static __inline__ vector unsigned short __ATTRS_o_ai
12241 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
12242  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
12243 }
12244 
12245 static __inline__ vector unsigned short __ATTRS_o_ai
12246 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
12247  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
12248 }
12249 
12250 /* vec_vsubsws */
12251 
12252 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
12253  vector int __b) {
12254  return __builtin_altivec_vsubsws(__a, __b);
12255 }
12256 
12257 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
12258  vector int __b) {
12259  return __builtin_altivec_vsubsws((vector int)__a, __b);
12260 }
12261 
12262 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
12263  vector bool int __b) {
12264  return __builtin_altivec_vsubsws(__a, (vector int)__b);
12265 }
12266 
12267 /* vec_vsubuws */
12268 
12269 static __inline__ vector unsigned int __ATTRS_o_ai
12270 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
12271  return __builtin_altivec_vsubuws(__a, __b);
12272 }
12273 
12274 static __inline__ vector unsigned int __ATTRS_o_ai
12275 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
12276  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
12277 }
12278 
12279 static __inline__ vector unsigned int __ATTRS_o_ai
12280 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
12281  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
12282 }
12283 
12284 #ifdef __POWER8_VECTOR__
12285 /* vec_vsubuqm */
12286 
12287 #ifdef __SIZEOF_INT128__
12288 static __inline__ vector signed __int128 __ATTRS_o_ai
12289 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
12290  return __a - __b;
12291 }
12292 
12293 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12294 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12295  return __a - __b;
12296 }
12297 #endif
12298 
12299 static __inline__ vector unsigned char __attribute__((__always_inline__))
12300 vec_sub_u128(vector unsigned char __a, vector unsigned char __b) {
12301  return __builtin_altivec_vsubuqm(__a, __b);
12302 }
12303 
12304 /* vec_vsubeuqm */
12305 
12306 #ifdef __SIZEOF_INT128__
12307 static __inline__ vector signed __int128 __ATTRS_o_ai
12308 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
12309  vector signed __int128 __c) {
12310  return __builtin_altivec_vsubeuqm(__a, __b, __c);
12311 }
12312 
12313 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12314 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
12315  vector unsigned __int128 __c) {
12316  return __builtin_altivec_vsubeuqm(__a, __b, __c);
12317 }
12318 
12319 static __inline__ vector signed __int128 __ATTRS_o_ai
12320 vec_sube(vector signed __int128 __a, vector signed __int128 __b,
12321  vector signed __int128 __c) {
12322  return __builtin_altivec_vsubeuqm(__a, __b, __c);
12323 }
12324 
12325 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12326 vec_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
12327  vector unsigned __int128 __c) {
12328  return __builtin_altivec_vsubeuqm(__a, __b, __c);
12329 }
12330 #endif
12331 
12332 static __inline__ vector unsigned char __attribute__((__always_inline__))
12333 vec_sube_u128(vector unsigned char __a, vector unsigned char __b,
12334  vector unsigned char __c) {
12335  return (vector unsigned char)__builtin_altivec_vsubeuqm(__a, __b, __c);
12336 }
12337 
12338 /* vec_vsubcuq */
12339 
12340 #ifdef __SIZEOF_INT128__
12341 static __inline__ vector signed __int128 __ATTRS_o_ai
12342 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
12343  return __builtin_altivec_vsubcuq(__a, __b);
12344 }
12345 
12346 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12347 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12348  return __builtin_altivec_vsubcuq(__a, __b);
12349 }
12350 
12351 /* vec_vsubecuq */
12352 
12353 static __inline__ vector signed __int128 __ATTRS_o_ai
12354 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
12355  vector signed __int128 __c) {
12356  return __builtin_altivec_vsubecuq(__a, __b, __c);
12357 }
12358 
12359 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12360 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
12361  vector unsigned __int128 __c) {
12362  return __builtin_altivec_vsubecuq(__a, __b, __c);
12363 }
12364 #endif
12365 
12366 #ifdef __powerpc64__
12367 static __inline__ vector signed int __ATTRS_o_ai
12368 vec_subec(vector signed int __a, vector signed int __b,
12369  vector signed int __c) {
12370  return vec_addec(__a, ~__b, __c);
12371 }
12372 
12373 static __inline__ vector unsigned int __ATTRS_o_ai
12374 vec_subec(vector unsigned int __a, vector unsigned int __b,
12375  vector unsigned int __c) {
12376  return vec_addec(__a, ~__b, __c);
12377 }
12378 #endif
12379 
12380 #ifdef __SIZEOF_INT128__
12381 static __inline__ vector signed __int128 __ATTRS_o_ai
12382 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
12383  vector signed __int128 __c) {
12384  return __builtin_altivec_vsubecuq(__a, __b, __c);
12385 }
12386 
12387 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12388 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
12389  vector unsigned __int128 __c) {
12390  return __builtin_altivec_vsubecuq(__a, __b, __c);
12391 }
12392 #endif
12393 
12394 static __inline__ vector unsigned char __attribute__((__always_inline__))
12395 vec_subec_u128(vector unsigned char __a, vector unsigned char __b,
12396  vector unsigned char __c) {
12397  return (vector unsigned char)__builtin_altivec_vsubecuq(__a, __b, __c);
12398 }
12399 #endif // __POWER8_VECTOR__
12400 
12401 static __inline__ vector signed int __ATTRS_o_ai
12402 vec_sube(vector signed int __a, vector signed int __b,
12403  vector signed int __c) {
12404  vector signed int __mask = {1, 1, 1, 1};
12405  vector signed int __carry = __c & __mask;
12406  return vec_adde(__a, ~__b, __carry);
12407 }
12408 
12409 static __inline__ vector unsigned int __ATTRS_o_ai
12410 vec_sube(vector unsigned int __a, vector unsigned int __b,
12411  vector unsigned int __c) {
12412  vector unsigned int __mask = {1, 1, 1, 1};
12413  vector unsigned int __carry = __c & __mask;
12414  return vec_adde(__a, ~__b, __carry);
12415 }
12416 /* vec_sum4s */
12417 
12418 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
12419  vector int __b) {
12420  return __builtin_altivec_vsum4sbs(__a, __b);
12421 }
12422 
12423 static __inline__ vector unsigned int __ATTRS_o_ai
12424 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
12425  return __builtin_altivec_vsum4ubs(__a, __b);
12426 }
12427 
12428 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
12429  vector int __b) {
12430  return __builtin_altivec_vsum4shs(__a, __b);
12431 }
12432 
12433 /* vec_vsum4sbs */
12434 
12435 static __inline__ vector int __attribute__((__always_inline__))
12436 vec_vsum4sbs(vector signed char __a, vector int __b) {
12437  return __builtin_altivec_vsum4sbs(__a, __b);
12438 }
12439 
12440 /* vec_vsum4ubs */
12441 
12442 static __inline__ vector unsigned int __attribute__((__always_inline__))
12443 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
12444  return __builtin_altivec_vsum4ubs(__a, __b);
12445 }
12446 
12447 /* vec_vsum4shs */
12448 
12449 static __inline__ vector int __attribute__((__always_inline__))
12450 vec_vsum4shs(vector signed short __a, vector int __b) {
12451  return __builtin_altivec_vsum4shs(__a, __b);
12452 }
12453 
12454 /* vec_sum2s */
12455 
12456 /* The vsum2sws instruction has a big-endian bias, so that the second
12457  input vector and the result always reference big-endian elements
12458  1 and 3 (little-endian element 0 and 2). For ease of porting the
12459  programmer wants elements 1 and 3 in both cases, so for little
12460  endian we must perform some permutes. */
12461 
12462 static __inline__ vector signed int __attribute__((__always_inline__))
12463 vec_sum2s(vector int __a, vector int __b) {
12464 #ifdef __LITTLE_ENDIAN__
12465  vector int __c = (vector signed int)vec_perm(
12466  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12467  8, 9, 10, 11));
12468  __c = __builtin_altivec_vsum2sws(__a, __c);
12469  return (vector signed int)vec_perm(
12470  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12471  8, 9, 10, 11));
12472 #else
12473  return __builtin_altivec_vsum2sws(__a, __b);
12474 #endif
12475 }
12476 
12477 /* vec_vsum2sws */
12478 
12479 static __inline__ vector signed int __attribute__((__always_inline__))
12480 vec_vsum2sws(vector int __a, vector int __b) {
12481 #ifdef __LITTLE_ENDIAN__
12482  vector int __c = (vector signed int)vec_perm(
12483  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12484  8, 9, 10, 11));
12485  __c = __builtin_altivec_vsum2sws(__a, __c);
12486  return (vector signed int)vec_perm(
12487  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12488  8, 9, 10, 11));
12489 #else
12490  return __builtin_altivec_vsum2sws(__a, __b);
12491 #endif
12492 }
12493 
12494 /* vec_sums */
12495 
12496 /* The vsumsws instruction has a big-endian bias, so that the second
12497  input vector and the result always reference big-endian element 3
12498  (little-endian element 0). For ease of porting the programmer
12499  wants element 3 in both cases, so for little endian we must perform
12500  some permutes. */
12501 
12502 static __inline__ vector signed int __attribute__((__always_inline__))
12503 vec_sums(vector signed int __a, vector signed int __b) {
12504 #ifdef __LITTLE_ENDIAN__
12505  __b = (vector signed int)vec_splat(__b, 3);
12506  __b = __builtin_altivec_vsumsws(__a, __b);
12507  return (vector signed int)(0, 0, 0, __b[0]);
12508 #else
12509  return __builtin_altivec_vsumsws(__a, __b);
12510 #endif
12511 }
12512 
12513 /* vec_vsumsws */
12514 
12515 static __inline__ vector signed int __attribute__((__always_inline__))
12516 vec_vsumsws(vector signed int __a, vector signed int __b) {
12517 #ifdef __LITTLE_ENDIAN__
12518  __b = (vector signed int)vec_splat(__b, 3);
12519  __b = __builtin_altivec_vsumsws(__a, __b);
12520  return (vector signed int)(0, 0, 0, __b[0]);
12521 #else
12522  return __builtin_altivec_vsumsws(__a, __b);
12523 #endif
12524 }
12525 
12526 /* vec_trunc */
12527 
12528 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
12529 #ifdef __VSX__
12530  return __builtin_vsx_xvrspiz(__a);
12531 #else
12532  return __builtin_altivec_vrfiz(__a);
12533 #endif
12534 }
12535 
12536 #ifdef __VSX__
12537 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
12538  return __builtin_vsx_xvrdpiz(__a);
12539 }
12540 #endif
12541 
12542 /* vec_roundz */
12543 static __inline__ vector float __ATTRS_o_ai vec_roundz(vector float __a) {
12544  return vec_trunc(__a);
12545 }
12546 
12547 #ifdef __VSX__
12548 static __inline__ vector double __ATTRS_o_ai vec_roundz(vector double __a) {
12549  return vec_trunc(__a);
12550 }
12551 #endif
12552 
12553 /* vec_vrfiz */
12554 
12555 static __inline__ vector float __attribute__((__always_inline__))
12556 vec_vrfiz(vector float __a) {
12557  return __builtin_altivec_vrfiz(__a);
12558 }
12559 
12560 /* vec_unpackh */
12561 
12562 /* The vector unpack instructions all have a big-endian bias, so for
12563  little endian we must reverse the meanings of "high" and "low." */
12564 #ifdef __LITTLE_ENDIAN__
12565 #define vec_vupkhpx(__a) __builtin_altivec_vupklpx((vector short)(__a))
12566 #define vec_vupklpx(__a) __builtin_altivec_vupkhpx((vector short)(__a))
12567 #else
12568 #define vec_vupkhpx(__a) __builtin_altivec_vupkhpx((vector short)(__a))
12569 #define vec_vupklpx(__a) __builtin_altivec_vupklpx((vector short)(__a))
12570 #endif
12571 
12572 static __inline__ vector short __ATTRS_o_ai
12573 vec_unpackh(vector signed char __a) {
12574 #ifdef __LITTLE_ENDIAN__
12575  return __builtin_altivec_vupklsb((vector char)__a);
12576 #else
12577  return __builtin_altivec_vupkhsb((vector char)__a);
12578 #endif
12579 }
12580 
12581 static __inline__ vector bool short __ATTRS_o_ai
12582 vec_unpackh(vector bool char __a) {
12583 #ifdef __LITTLE_ENDIAN__
12584  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12585 #else
12586  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12587 #endif
12588 }
12589 
12590 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
12591 #ifdef __LITTLE_ENDIAN__
12592  return __builtin_altivec_vupklsh(__a);
12593 #else
12594  return __builtin_altivec_vupkhsh(__a);
12595 #endif
12596 }
12597 
12598 static __inline__ vector bool int __ATTRS_o_ai
12599 vec_unpackh(vector bool short __a) {
12600 #ifdef __LITTLE_ENDIAN__
12601  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12602 #else
12603  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12604 #endif
12605 }
12606 
12607 static __inline__ vector unsigned int __ATTRS_o_ai
12608 vec_unpackh(vector pixel __a) {
12609 #ifdef __LITTLE_ENDIAN__
12610  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12611 #else
12612  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12613 #endif
12614 }
12615 
12616 #ifdef __POWER8_VECTOR__
12617 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
12618 #ifdef __LITTLE_ENDIAN__
12619  return __builtin_altivec_vupklsw(__a);
12620 #else
12621  return __builtin_altivec_vupkhsw(__a);
12622 #endif
12623 }
12624 
12625 static __inline__ vector bool long long __ATTRS_o_ai
12626 vec_unpackh(vector bool int __a) {
12627 #ifdef __LITTLE_ENDIAN__
12628  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12629 #else
12630  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12631 #endif
12632 }
12633 
12634 static __inline__ vector double __ATTRS_o_ai
12635 vec_unpackh(vector float __a) {
12636  return (vector double)(__a[0], __a[1]);
12637 }
12638 #endif
12639 
12640 /* vec_vupkhsb */
12641 
12642 static __inline__ vector short __ATTRS_o_ai
12643 vec_vupkhsb(vector signed char __a) {
12644 #ifdef __LITTLE_ENDIAN__
12645  return __builtin_altivec_vupklsb((vector char)__a);
12646 #else
12647  return __builtin_altivec_vupkhsb((vector char)__a);
12648 #endif
12649 }
12650 
12651 static __inline__ vector bool short __ATTRS_o_ai
12652 vec_vupkhsb(vector bool char __a) {
12653 #ifdef __LITTLE_ENDIAN__
12654  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12655 #else
12656  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12657 #endif
12658 }
12659 
12660 /* vec_vupkhsh */
12661 
12662 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
12663 #ifdef __LITTLE_ENDIAN__
12664  return __builtin_altivec_vupklsh(__a);
12665 #else
12666  return __builtin_altivec_vupkhsh(__a);
12667 #endif
12668 }
12669 
12670 static __inline__ vector bool int __ATTRS_o_ai
12671 vec_vupkhsh(vector bool short __a) {
12672 #ifdef __LITTLE_ENDIAN__
12673  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12674 #else
12675  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12676 #endif
12677 }
12678 
12679 static __inline__ vector unsigned int __ATTRS_o_ai
12680 vec_vupkhsh(vector pixel __a) {
12681 #ifdef __LITTLE_ENDIAN__
12682  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12683 #else
12684  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12685 #endif
12686 }
12687 
12688 /* vec_vupkhsw */
12689 
12690 #ifdef __POWER8_VECTOR__
12691 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
12692 #ifdef __LITTLE_ENDIAN__
12693  return __builtin_altivec_vupklsw(__a);
12694 #else
12695  return __builtin_altivec_vupkhsw(__a);
12696 #endif
12697 }
12698 
12699 static __inline__ vector bool long long __ATTRS_o_ai
12700 vec_vupkhsw(vector bool int __a) {
12701 #ifdef __LITTLE_ENDIAN__
12702  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12703 #else
12704  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12705 #endif
12706 }
12707 #endif
12708 
12709 /* vec_unpackl */
12710 
12711 static __inline__ vector short __ATTRS_o_ai
12712 vec_unpackl(vector signed char __a) {
12713 #ifdef __LITTLE_ENDIAN__
12714  return __builtin_altivec_vupkhsb((vector char)__a);
12715 #else
12716  return __builtin_altivec_vupklsb((vector char)__a);
12717 #endif
12718 }
12719 
12720 static __inline__ vector bool short __ATTRS_o_ai
12721 vec_unpackl(vector bool char __a) {
12722 #ifdef __LITTLE_ENDIAN__
12723  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12724 #else
12725  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12726 #endif
12727 }
12728 
12729 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
12730 #ifdef __LITTLE_ENDIAN__
12731  return __builtin_altivec_vupkhsh(__a);
12732 #else
12733  return __builtin_altivec_vupklsh(__a);
12734 #endif
12735 }
12736 
12737 static __inline__ vector bool int __ATTRS_o_ai
12738 vec_unpackl(vector bool short __a) {
12739 #ifdef __LITTLE_ENDIAN__
12740  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12741 #else
12742  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12743 #endif
12744 }
12745 
12746 static __inline__ vector unsigned int __ATTRS_o_ai
12747 vec_unpackl(vector pixel __a) {
12748 #ifdef __LITTLE_ENDIAN__
12749  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12750 #else
12751  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12752 #endif
12753 }
12754 
12755 #ifdef __POWER8_VECTOR__
12756 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
12757 #ifdef __LITTLE_ENDIAN__
12758  return __builtin_altivec_vupkhsw(__a);
12759 #else
12760  return __builtin_altivec_vupklsw(__a);
12761 #endif
12762 }
12763 
12764 static __inline__ vector bool long long __ATTRS_o_ai
12765 vec_unpackl(vector bool int __a) {
12766 #ifdef __LITTLE_ENDIAN__
12767  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12768 #else
12769  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12770 #endif
12771 }
12772 
12773 static __inline__ vector double __ATTRS_o_ai
12774 vec_unpackl(vector float __a) {
12775  return (vector double)(__a[2], __a[3]);
12776 }
12777 #endif
12778 
12779 /* vec_vupklsb */
12780 
12781 static __inline__ vector short __ATTRS_o_ai
12782 vec_vupklsb(vector signed char __a) {
12783 #ifdef __LITTLE_ENDIAN__
12784  return __builtin_altivec_vupkhsb((vector char)__a);
12785 #else
12786  return __builtin_altivec_vupklsb((vector char)__a);
12787 #endif
12788 }
12789 
12790 static __inline__ vector bool short __ATTRS_o_ai
12791 vec_vupklsb(vector bool char __a) {
12792 #ifdef __LITTLE_ENDIAN__
12793  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12794 #else
12795  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12796 #endif
12797 }
12798 
12799 /* vec_vupklsh */
12800 
12801 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
12802 #ifdef __LITTLE_ENDIAN__
12803  return __builtin_altivec_vupkhsh(__a);
12804 #else
12805  return __builtin_altivec_vupklsh(__a);
12806 #endif
12807 }
12808 
12809 static __inline__ vector bool int __ATTRS_o_ai
12810 vec_vupklsh(vector bool short __a) {
12811 #ifdef __LITTLE_ENDIAN__
12812  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12813 #else
12814  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12815 #endif
12816 }
12817 
12818 static __inline__ vector unsigned int __ATTRS_o_ai
12819 vec_vupklsh(vector pixel __a) {
12820 #ifdef __LITTLE_ENDIAN__
12821  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12822 #else
12823  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12824 #endif
12825 }
12826 
12827 /* vec_vupklsw */
12828 
12829 #ifdef __POWER8_VECTOR__
12830 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
12831 #ifdef __LITTLE_ENDIAN__
12832  return __builtin_altivec_vupkhsw(__a);
12833 #else
12834  return __builtin_altivec_vupklsw(__a);
12835 #endif
12836 }
12837 
12838 static __inline__ vector bool long long __ATTRS_o_ai
12839 vec_vupklsw(vector bool int __a) {
12840 #ifdef __LITTLE_ENDIAN__
12841  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12842 #else
12843  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12844 #endif
12845 }
12846 #endif
12847 
12848 /* vec_vsx_ld */
12849 
12850 #ifdef __VSX__
12851 
12852 static __inline__ vector bool int __ATTRS_o_ai
12853 vec_vsx_ld(int __a, const vector bool int *__b) {
12854  return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
12855 }
12856 
12857 static __inline__ vector signed int __ATTRS_o_ai
12858 vec_vsx_ld(int __a, const vector signed int *__b) {
12859  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
12860 }
12861 
12862 static __inline__ vector signed int __ATTRS_o_ai
12863 vec_vsx_ld(int __a, const signed int *__b) {
12864  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
12865 }
12866 
12867 static __inline__ vector unsigned int __ATTRS_o_ai
12868 vec_vsx_ld(int __a, const vector unsigned int *__b) {
12869  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
12870 }
12871 
12872 static __inline__ vector unsigned int __ATTRS_o_ai
12873 vec_vsx_ld(int __a, const unsigned int *__b) {
12874  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
12875 }
12876 
12877 static __inline__ vector float __ATTRS_o_ai
12878 vec_vsx_ld(int __a, const vector float *__b) {
12879  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
12880 }
12881 
12882 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
12883  const float *__b) {
12884  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
12885 }
12886 
12887 static __inline__ vector signed long long __ATTRS_o_ai
12888 vec_vsx_ld(int __a, const vector signed long long *__b) {
12889  return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
12890 }
12891 
12892 static __inline__ vector unsigned long long __ATTRS_o_ai
12893 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
12894  return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
12895 }
12896 
12897 static __inline__ vector double __ATTRS_o_ai
12898 vec_vsx_ld(int __a, const vector double *__b) {
12899  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
12900 }
12901 
12902 static __inline__ vector double __ATTRS_o_ai
12903 vec_vsx_ld(int __a, const double *__b) {
12904  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
12905 }
12906 
12907 static __inline__ vector bool short __ATTRS_o_ai
12908 vec_vsx_ld(int __a, const vector bool short *__b) {
12909  return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
12910 }
12911 
12912 static __inline__ vector signed short __ATTRS_o_ai
12913 vec_vsx_ld(int __a, const vector signed short *__b) {
12914  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
12915 }
12916 
12917 static __inline__ vector signed short __ATTRS_o_ai
12918 vec_vsx_ld(int __a, const signed short *__b) {
12919  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
12920 }
12921 
12922 static __inline__ vector unsigned short __ATTRS_o_ai
12923 vec_vsx_ld(int __a, const vector unsigned short *__b) {
12924  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
12925 }
12926 
12927 static __inline__ vector unsigned short __ATTRS_o_ai
12928 vec_vsx_ld(int __a, const unsigned short *__b) {
12929  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
12930 }
12931 
12932 static __inline__ vector bool char __ATTRS_o_ai
12933 vec_vsx_ld(int __a, const vector bool char *__b) {
12934  return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
12935 }
12936 
12937 static __inline__ vector signed char __ATTRS_o_ai
12938 vec_vsx_ld(int __a, const vector signed char *__b) {
12939  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
12940 }
12941 
12942 static __inline__ vector signed char __ATTRS_o_ai
12943 vec_vsx_ld(int __a, const signed char *__b) {
12944  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
12945 }
12946 
12947 static __inline__ vector unsigned char __ATTRS_o_ai
12948 vec_vsx_ld(int __a, const vector unsigned char *__b) {
12949  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12950 }
12951 
12952 static __inline__ vector unsigned char __ATTRS_o_ai
12953 vec_vsx_ld(int __a, const unsigned char *__b) {
12954  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12955 }
12956 
12957 #endif
12958 
12959 /* vec_vsx_st */
12960 
12961 #ifdef __VSX__
12962 
12963 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12964  vector bool int *__c) {
12965  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12966 }
12967 
12968 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12969  signed int *__c) {
12970  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12971 }
12972 
12973 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12974  unsigned int *__c) {
12975  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12976 }
12977 
12978 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12979  vector signed int *__c) {
12980  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12981 }
12982 
12983 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12984  signed int *__c) {
12985  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12986 }
12987 
12988 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12989  vector unsigned int *__c) {
12990  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12991 }
12992 
12993 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12994  unsigned int *__c) {
12995  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12996 }
12997 
12998 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12999  vector float *__c) {
13000  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13001 }
13002 
13003 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
13004  float *__c) {
13005  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13006 }
13007 
13008 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
13009  int __b,
13010  vector signed long long *__c) {
13011  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13012 }
13013 
13014 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
13015  int __b,
13016  vector unsigned long long *__c) {
13017  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13018 }
13019 
13020 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
13021  vector double *__c) {
13022  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13023 }
13024 
13025 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
13026  double *__c) {
13027  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13028 }
13029 
13030 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13031  vector bool short *__c) {
13032  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13033 }
13034 
13035 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13036  signed short *__c) {
13037  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13038 }
13039 
13040 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13041  unsigned short *__c) {
13042  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13043 }
13044 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
13045  vector signed short *__c) {
13046  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13047 }
13048 
13049 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
13050  signed short *__c) {
13051  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13052 }
13053 
13054 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
13055  int __b,
13056  vector unsigned short *__c) {
13057  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13058 }
13059 
13060 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
13061  int __b, unsigned short *__c) {
13062  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13063 }
13064 
13065 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13066  vector bool char *__c) {
13067  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13068 }
13069 
13070 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13071  signed char *__c) {
13072  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13073 }
13074 
13075 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13076  unsigned char *__c) {
13077  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13078 }
13079 
13080 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
13081  vector signed char *__c) {
13082  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13083 }
13084 
13085 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
13086  signed char *__c) {
13087  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13088 }
13089 
13090 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
13091  int __b,
13092  vector unsigned char *__c) {
13093  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13094 }
13095 
13096 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
13097  int __b, unsigned char *__c) {
13098  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13099 }
13100 
13101 #endif
13102 
13103 #ifdef __VSX__
13104 #define vec_xxpermdi __builtin_vsx_xxpermdi
13105 #define vec_xxsldwi __builtin_vsx_xxsldwi
13106 #define vec_permi(__a, __b, __c) \
13107  _Generic((__a), vector signed long long \
13108  : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1), \
13109  (((__c)&0x1) + 2)), \
13110  vector unsigned long long \
13111  : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1), \
13112  (((__c)&0x1) + 2)), \
13113  vector double \
13114  : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1), \
13115  (((__c)&0x1) + 2)))
13116 #endif
13117 
13118 /* vec_xor */
13119 
13120 #define __builtin_altivec_vxor vec_xor
13121 
13122 static __inline__ vector signed char __ATTRS_o_ai
13123 vec_xor(vector signed char __a, vector signed char __b) {
13124  return __a ^ __b;
13125 }
13126 
13127 static __inline__ vector signed char __ATTRS_o_ai
13128 vec_xor(vector bool char __a, vector signed char __b) {
13129  return (vector signed char)__a ^ __b;
13130 }
13131 
13132 static __inline__ vector signed char __ATTRS_o_ai
13133 vec_xor(vector signed char __a, vector bool char __b) {
13134  return __a ^ (vector signed char)__b;
13135 }
13136 
13137 static __inline__ vector unsigned char __ATTRS_o_ai
13138 vec_xor(vector unsigned char __a, vector unsigned char __b) {
13139  return __a ^ __b;
13140 }
13141 
13142 static __inline__ vector unsigned char __ATTRS_o_ai
13143 vec_xor(vector bool char __a, vector unsigned char __b) {
13144  return (vector unsigned char)__a ^ __b;
13145 }
13146 
13147 static __inline__ vector unsigned char __ATTRS_o_ai
13148 vec_xor(vector unsigned char __a, vector bool char __b) {
13149  return __a ^ (vector unsigned char)__b;
13150 }
13151 
13152 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
13153  vector bool char __b) {
13154  return __a ^ __b;
13155 }
13156 
13157 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
13158  vector short __b) {
13159  return __a ^ __b;
13160 }
13161 
13162 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
13163  vector short __b) {
13164  return (vector short)__a ^ __b;
13165 }
13166 
13167 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
13168  vector bool short __b) {
13169  return __a ^ (vector short)__b;
13170 }
13171 
13172 static __inline__ vector unsigned short __ATTRS_o_ai
13173 vec_xor(vector unsigned short __a, vector unsigned short __b) {
13174  return __a ^ __b;
13175 }
13176 
13177 static __inline__ vector unsigned short __ATTRS_o_ai
13178 vec_xor(vector bool short __a, vector unsigned short __b) {
13179  return (vector unsigned short)__a ^ __b;
13180 }
13181 
13182 static __inline__ vector unsigned short __ATTRS_o_ai
13183 vec_xor(vector unsigned short __a, vector bool short __b) {
13184  return __a ^ (vector unsigned short)__b;
13185 }
13186 
13187 static __inline__ vector bool short __ATTRS_o_ai
13188 vec_xor(vector bool short __a, vector bool short __b) {
13189  return __a ^ __b;
13190 }
13191 
13192 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
13193  vector int __b) {
13194  return __a ^ __b;
13195 }
13196 
13197 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
13198  vector int __b) {
13199  return (vector int)__a ^ __b;
13200 }
13201 
13202 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
13203  vector bool int __b) {
13204  return __a ^ (vector int)__b;
13205 }
13206 
13207 static __inline__ vector unsigned int __ATTRS_o_ai
13208 vec_xor(vector unsigned int __a, vector unsigned int __b) {
13209  return __a ^ __b;
13210 }
13211 
13212 static __inline__ vector unsigned int __ATTRS_o_ai
13213 vec_xor(vector bool int __a, vector unsigned int __b) {
13214  return (vector unsigned int)__a ^ __b;
13215 }
13216 
13217 static __inline__ vector unsigned int __ATTRS_o_ai
13218 vec_xor(vector unsigned int __a, vector bool int __b) {
13219  return __a ^ (vector unsigned int)__b;
13220 }
13221 
13222 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
13223  vector bool int __b) {
13224  return __a ^ __b;
13225 }
13226 
13227 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
13228  vector float __b) {
13229  vector unsigned int __res =
13230  (vector unsigned int)__a ^ (vector unsigned int)__b;
13231  return (vector float)__res;
13232 }
13233 
13234 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
13235  vector float __b) {
13236  vector unsigned int __res =
13237  (vector unsigned int)__a ^ (vector unsigned int)__b;
13238  return (vector float)__res;
13239 }
13240 
13241 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
13242  vector bool int __b) {
13243  vector unsigned int __res =
13244  (vector unsigned int)__a ^ (vector unsigned int)__b;
13245  return (vector float)__res;
13246 }
13247 
13248 #ifdef __VSX__
13249 static __inline__ vector signed long long __ATTRS_o_ai
13250 vec_xor(vector signed long long __a, vector signed long long __b) {
13251  return __a ^ __b;
13252 }
13253 
13254 static __inline__ vector signed long long __ATTRS_o_ai
13255 vec_xor(vector bool long long __a, vector signed long long __b) {
13256  return (vector signed long long)__a ^ __b;
13257 }
13258 
13259 static __inline__ vector signed long long __ATTRS_o_ai
13260 vec_xor(vector signed long long __a, vector bool long long __b) {
13261  return __a ^ (vector signed long long)__b;
13262 }
13263 
13264 static __inline__ vector unsigned long long __ATTRS_o_ai
13265 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
13266  return __a ^ __b;
13267 }
13268 
13269 static __inline__ vector unsigned long long __ATTRS_o_ai
13270 vec_xor(vector bool long long __a, vector unsigned long long __b) {
13271  return (vector unsigned long long)__a ^ __b;
13272 }
13273 
13274 static __inline__ vector unsigned long long __ATTRS_o_ai
13275 vec_xor(vector unsigned long long __a, vector bool long long __b) {
13276  return __a ^ (vector unsigned long long)__b;
13277 }
13278 
13279 static __inline__ vector bool long long __ATTRS_o_ai
13280 vec_xor(vector bool long long __a, vector bool long long __b) {
13281  return __a ^ __b;
13282 }
13283 
13284 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
13285  vector double __b) {
13286  return (vector double)((vector unsigned long long)__a ^
13287  (vector unsigned long long)__b);
13288 }
13289 
13290 static __inline__ vector double __ATTRS_o_ai
13291 vec_xor(vector double __a, vector bool long long __b) {
13292  return (vector double)((vector unsigned long long)__a ^
13293  (vector unsigned long long)__b);
13294 }
13295 
13296 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
13297  vector double __b) {
13298  return (vector double)((vector unsigned long long)__a ^
13299  (vector unsigned long long)__b);
13300 }
13301 #endif
13302 
13303 /* vec_vxor */
13304 
13305 static __inline__ vector signed char __ATTRS_o_ai
13306 vec_vxor(vector signed char __a, vector signed char __b) {
13307  return __a ^ __b;
13308 }
13309 
13310 static __inline__ vector signed char __ATTRS_o_ai
13311 vec_vxor(vector bool char __a, vector signed char __b) {
13312  return (vector signed char)__a ^ __b;
13313 }
13314 
13315 static __inline__ vector signed char __ATTRS_o_ai
13316 vec_vxor(vector signed char __a, vector bool char __b) {
13317  return __a ^ (vector signed char)__b;
13318 }
13319 
13320 static __inline__ vector unsigned char __ATTRS_o_ai
13321 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
13322  return __a ^ __b;
13323 }
13324 
13325 static __inline__ vector unsigned char __ATTRS_o_ai
13326 vec_vxor(vector bool char __a, vector unsigned char __b) {
13327  return (vector unsigned char)__a ^ __b;
13328 }
13329 
13330 static __inline__ vector unsigned char __ATTRS_o_ai
13331 vec_vxor(vector unsigned char __a, vector bool char __b) {
13332  return __a ^ (vector unsigned char)__b;
13333 }
13334 
13335 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
13336  vector bool char __b) {
13337  return __a ^ __b;
13338 }
13339 
13340 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
13341  vector short __b) {
13342  return __a ^ __b;
13343 }
13344 
13345 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
13346  vector short __b) {
13347  return (vector short)__a ^ __b;
13348 }
13349 
13350 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
13351  vector bool short __b) {
13352  return __a ^ (vector short)__b;
13353 }
13354 
13355 static __inline__ vector unsigned short __ATTRS_o_ai
13356 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
13357  return __a ^ __b;
13358 }
13359 
13360 static __inline__ vector unsigned short __ATTRS_o_ai
13361 vec_vxor(vector bool short __a, vector unsigned short __b) {
13362  return (vector unsigned short)__a ^ __b;
13363 }
13364 
13365 static __inline__ vector unsigned short __ATTRS_o_ai
13366 vec_vxor(vector unsigned short __a, vector bool short __b) {
13367  return __a ^ (vector unsigned short)__b;
13368 }
13369 
13370 static __inline__ vector bool short __ATTRS_o_ai
13371 vec_vxor(vector bool short __a, vector bool short __b) {
13372  return __a ^ __b;
13373 }
13374 
13375 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
13376  vector int __b) {
13377  return __a ^ __b;
13378 }
13379 
13380 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
13381  vector int __b) {
13382  return (vector int)__a ^ __b;
13383 }
13384 
13385 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
13386  vector bool int __b) {
13387  return __a ^ (vector int)__b;
13388 }
13389 
13390 static __inline__ vector unsigned int __ATTRS_o_ai
13391 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
13392  return __a ^ __b;
13393 }
13394 
13395 static __inline__ vector unsigned int __ATTRS_o_ai
13396 vec_vxor(vector bool int __a, vector unsigned int __b) {
13397  return (vector unsigned int)__a ^ __b;
13398 }
13399 
13400 static __inline__ vector unsigned int __ATTRS_o_ai
13401 vec_vxor(vector unsigned int __a, vector bool int __b) {
13402  return __a ^ (vector unsigned int)__b;
13403 }
13404 
13405 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
13406  vector bool int __b) {
13407  return __a ^ __b;
13408 }
13409 
13410 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
13411  vector float __b) {
13412  vector unsigned int __res =
13413  (vector unsigned int)__a ^ (vector unsigned int)__b;
13414  return (vector float)__res;
13415 }
13416 
13417 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
13418  vector float __b) {
13419  vector unsigned int __res =
13420  (vector unsigned int)__a ^ (vector unsigned int)__b;
13421  return (vector float)__res;
13422 }
13423 
13424 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
13425  vector bool int __b) {
13426  vector unsigned int __res =
13427  (vector unsigned int)__a ^ (vector unsigned int)__b;
13428  return (vector float)__res;
13429 }
13430 
13431 #ifdef __VSX__
13432 static __inline__ vector signed long long __ATTRS_o_ai
13433 vec_vxor(vector signed long long __a, vector signed long long __b) {
13434  return __a ^ __b;
13435 }
13436 
13437 static __inline__ vector signed long long __ATTRS_o_ai
13438 vec_vxor(vector bool long long __a, vector signed long long __b) {
13439  return (vector signed long long)__a ^ __b;
13440 }
13441 
13442 static __inline__ vector signed long long __ATTRS_o_ai
13443 vec_vxor(vector signed long long __a, vector bool long long __b) {
13444  return __a ^ (vector signed long long)__b;
13445 }
13446 
13447 static __inline__ vector unsigned long long __ATTRS_o_ai
13448 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
13449  return __a ^ __b;
13450 }
13451 
13452 static __inline__ vector unsigned long long __ATTRS_o_ai
13453 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
13454  return (vector unsigned long long)__a ^ __b;
13455 }
13456 
13457 static __inline__ vector unsigned long long __ATTRS_o_ai
13458 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
13459  return __a ^ (vector unsigned long long)__b;
13460 }
13461 
13462 static __inline__ vector bool long long __ATTRS_o_ai
13463 vec_vxor(vector bool long long __a, vector bool long long __b) {
13464  return __a ^ __b;
13465 }
13466 #endif
13467 
13468 /* ------------------------ extensions for CBEA ----------------------------- */
13469 
13470 /* vec_extract */
13471 
13472 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
13473  signed int __b) {
13474  return __a[__b & 0xf];
13475 }
13476 
13477 static __inline__ unsigned char __ATTRS_o_ai
13478 vec_extract(vector unsigned char __a, signed int __b) {
13479  return __a[__b & 0xf];
13480 }
13481 
13482 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
13483  signed int __b) {
13484  return __a[__b & 0xf];
13485 }
13486 
13487 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
13488  signed int __b) {
13489  return __a[__b & 0x7];
13490 }
13491 
13492 static __inline__ unsigned short __ATTRS_o_ai
13493 vec_extract(vector unsigned short __a, signed int __b) {
13494  return __a[__b & 0x7];
13495 }
13496 
13497 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
13498  signed int __b) {
13499  return __a[__b & 0x7];
13500 }
13501 
13502 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
13503  signed int __b) {
13504  return __a[__b & 0x3];
13505 }
13506 
13507 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
13508  signed int __b) {
13509  return __a[__b & 0x3];
13510 }
13511 
13512 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
13513  signed int __b) {
13514  return __a[__b & 0x3];
13515 }
13516 
13517 #ifdef __VSX__
13518 static __inline__ signed long long __ATTRS_o_ai
13519 vec_extract(vector signed long long __a, signed int __b) {
13520  return __a[__b & 0x1];
13521 }
13522 
13523 static __inline__ unsigned long long __ATTRS_o_ai
13524 vec_extract(vector unsigned long long __a, signed int __b) {
13525  return __a[__b & 0x1];
13526 }
13527 
13528 static __inline__ unsigned long long __ATTRS_o_ai
13529 vec_extract(vector bool long long __a, signed int __b) {
13530  return __a[__b & 0x1];
13531 }
13532 
13533 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a,
13534  signed int __b) {
13535  return __a[__b & 0x1];
13536 }
13537 #endif
13538 
13539 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a,
13540  signed int __b) {
13541  return __a[__b & 0x3];
13542 }
13543 
13544 #ifdef __POWER9_VECTOR__
13545 
13546 #define vec_insert4b __builtin_vsx_insertword
13547 #define vec_extract4b __builtin_vsx_extractuword
13548 
13549 /* vec_extract_exp */
13550 
13551 static __inline__ vector unsigned int __ATTRS_o_ai
13552 vec_extract_exp(vector float __a) {
13553  return __builtin_vsx_xvxexpsp(__a);
13554 }
13555 
13556 static __inline__ vector unsigned long long __ATTRS_o_ai
13557 vec_extract_exp(vector double __a) {
13558  return __builtin_vsx_xvxexpdp(__a);
13559 }
13560 
13561 /* vec_extract_sig */
13562 
13563 static __inline__ vector unsigned int __ATTRS_o_ai
13564 vec_extract_sig(vector float __a) {
13565  return __builtin_vsx_xvxsigsp(__a);
13566 }
13567 
13568 static __inline__ vector unsigned long long __ATTRS_o_ai
13569 vec_extract_sig (vector double __a) {
13570  return __builtin_vsx_xvxsigdp(__a);
13571 }
13572 
13573 static __inline__ vector float __ATTRS_o_ai
13574 vec_extract_fp32_from_shorth(vector unsigned short __a) {
13575  vector unsigned short __b =
13576 #ifdef __LITTLE_ENDIAN__
13577  __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
13578 #else
13579  __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
13580 #endif
13581  return __builtin_vsx_xvcvhpsp(__b);
13582 }
13583 
13584 static __inline__ vector float __ATTRS_o_ai
13585 vec_extract_fp32_from_shortl(vector unsigned short __a) {
13586  vector unsigned short __b =
13587 #ifdef __LITTLE_ENDIAN__
13588  __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
13589 #else
13590  __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
13591 #endif
13592  return __builtin_vsx_xvcvhpsp(__b);
13593 }
13594 #endif /* __POWER9_VECTOR__ */
13595 
13596 /* vec_insert */
13597 
13598 static __inline__ vector signed char __ATTRS_o_ai
13599 vec_insert(signed char __a, vector signed char __b, int __c) {
13600  __b[__c & 0xF] = __a;
13601  return __b;
13602 }
13603 
13604 static __inline__ vector unsigned char __ATTRS_o_ai
13605 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
13606  __b[__c & 0xF] = __a;
13607  return __b;
13608 }
13609 
13610 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
13611  vector bool char __b,
13612  int __c) {
13613  __b[__c & 0xF] = __a;
13614  return __b;
13615 }
13616 
13617 static __inline__ vector signed short __ATTRS_o_ai
13618 vec_insert(signed short __a, vector signed short __b, int __c) {
13619  __b[__c & 0x7] = __a;
13620  return __b;
13621 }
13622 
13623 static __inline__ vector unsigned short __ATTRS_o_ai
13624 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
13625  __b[__c & 0x7] = __a;
13626  return __b;
13627 }
13628 
13629 static __inline__ vector bool short __ATTRS_o_ai
13630 vec_insert(unsigned short __a, vector bool short __b, int __c) {
13631  __b[__c & 0x7] = __a;
13632  return __b;
13633 }
13634 
13635 static __inline__ vector signed int __ATTRS_o_ai
13636 vec_insert(signed int __a, vector signed int __b, int __c) {
13637  __b[__c & 0x3] = __a;
13638  return __b;
13639 }
13640 
13641 static __inline__ vector unsigned int __ATTRS_o_ai
13642 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
13643  __b[__c & 0x3] = __a;
13644  return __b;
13645 }
13646 
13647 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
13648  vector bool int __b,
13649  int __c) {
13650  __b[__c & 0x3] = __a;
13651  return __b;
13652 }
13653 
13654 #ifdef __VSX__
13655 static __inline__ vector signed long long __ATTRS_o_ai
13656 vec_insert(signed long long __a, vector signed long long __b, int __c) {
13657  __b[__c & 0x1] = __a;
13658  return __b;
13659 }
13660 
13661 static __inline__ vector unsigned long long __ATTRS_o_ai
13662 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
13663  __b[__c & 0x1] = __a;
13664  return __b;
13665 }
13666 
13667 static __inline__ vector bool long long __ATTRS_o_ai
13668 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
13669  __b[__c & 0x1] = __a;
13670  return __b;
13671 }
13672 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
13673  vector double __b,
13674  int __c) {
13675  __b[__c & 0x1] = __a;
13676  return __b;
13677 }
13678 #endif
13679 
13680 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
13681  vector float __b,
13682  int __c) {
13683  __b[__c & 0x3] = __a;
13684  return __b;
13685 }
13686 
13687 /* vec_lvlx */
13688 
13689 static __inline__ vector signed char __ATTRS_o_ai
13690 vec_lvlx(int __a, const signed char *__b) {
13691  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
13692  vec_lvsl(__a, __b));
13693 }
13694 
13695 static __inline__ vector signed char __ATTRS_o_ai
13696 vec_lvlx(int __a, const vector signed char *__b) {
13697  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
13698  vec_lvsl(__a, (unsigned char *)__b));
13699 }
13700 
13701 static __inline__ vector unsigned char __ATTRS_o_ai
13702 vec_lvlx(int __a, const unsigned char *__b) {
13703  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
13704  vec_lvsl(__a, __b));
13705 }
13706 
13707 static __inline__ vector unsigned char __ATTRS_o_ai
13708 vec_lvlx(int __a, const vector unsigned char *__b) {
13709  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
13710  vec_lvsl(__a, (unsigned char *)__b));
13711 }
13712 
13713 static __inline__ vector bool char __ATTRS_o_ai
13714 vec_lvlx(int __a, const vector bool char *__b) {
13715  return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
13716  vec_lvsl(__a, (unsigned char *)__b));
13717 }
13718 
13719 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
13720  const short *__b) {
13721  return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
13722 }
13723 
13724 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
13725  const vector short *__b) {
13726  return vec_perm(vec_ld(__a, __b), (vector short)(0),
13727  vec_lvsl(__a, (unsigned char *)__b));
13728 }
13729 
13730 static __inline__ vector unsigned short __ATTRS_o_ai
13731 vec_lvlx(int __a, const unsigned short *__b) {
13732  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
13733  vec_lvsl(__a, __b));
13734 }
13735 
13736 static __inline__ vector unsigned short __ATTRS_o_ai
13737 vec_lvlx(int __a, const vector unsigned short *__b) {
13738  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
13739  vec_lvsl(__a, (unsigned char *)__b));
13740 }
13741 
13742 static __inline__ vector bool short __ATTRS_o_ai
13743 vec_lvlx(int __a, const vector bool short *__b) {
13744  return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
13745  vec_lvsl(__a, (unsigned char *)__b));
13746 }
13747 
13748 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
13749  const vector pixel *__b) {
13750  return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
13751  vec_lvsl(__a, (unsigned char *)__b));
13752 }
13753 
13754 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
13755  return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
13756 }
13757 
13758 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
13759  const vector int *__b) {
13760  return vec_perm(vec_ld(__a, __b), (vector int)(0),
13761  vec_lvsl(__a, (unsigned char *)__b));
13762 }
13763 
13764 static __inline__ vector unsigned int __ATTRS_o_ai
13765 vec_lvlx(int __a, const unsigned int *__b) {
13766  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
13767  vec_lvsl(__a, __b));
13768 }
13769 
13770 static __inline__ vector unsigned int __ATTRS_o_ai
13771 vec_lvlx(int __a, const vector unsigned int *__b) {
13772  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
13773  vec_lvsl(__a, (unsigned char *)__b));
13774 }
13775 
13776 static __inline__ vector bool int __ATTRS_o_ai
13777 vec_lvlx(int __a, const vector bool int *__b) {
13778  return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
13779  vec_lvsl(__a, (unsigned char *)__b));
13780 }
13781 
13782 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
13783  const float *__b) {
13784  return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
13785 }
13786 
13787 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
13788  const vector float *__b) {
13789  return vec_perm(vec_ld(__a, __b), (vector float)(0),
13790  vec_lvsl(__a, (unsigned char *)__b));
13791 }
13792 
13793 /* vec_lvlxl */
13794 
13795 static __inline__ vector signed char __ATTRS_o_ai
13796 vec_lvlxl(int __a, const signed char *__b) {
13797  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
13798  vec_lvsl(__a, __b));
13799 }
13800 
13801 static __inline__ vector signed char __ATTRS_o_ai
13802 vec_lvlxl(int __a, const vector signed char *__b) {
13803  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
13804  vec_lvsl(__a, (unsigned char *)__b));
13805 }
13806 
13807 static __inline__ vector unsigned char __ATTRS_o_ai
13808 vec_lvlxl(int __a, const unsigned char *__b) {
13809  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
13810  vec_lvsl(__a, __b));
13811 }
13812 
13813 static __inline__ vector unsigned char __ATTRS_o_ai
13814 vec_lvlxl(int __a, const vector unsigned char *__b) {
13815  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
13816  vec_lvsl(__a, (unsigned char *)__b));
13817 }
13818 
13819 static __inline__ vector bool char __ATTRS_o_ai
13820 vec_lvlxl(int __a, const vector bool char *__b) {
13821  return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
13822  vec_lvsl(__a, (unsigned char *)__b));
13823 }
13824 
13825 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
13826  const short *__b) {
13827  return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
13828 }
13829 
13830 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
13831  const vector short *__b) {
13832  return vec_perm(vec_ldl(__a, __b), (vector short)(0),
13833  vec_lvsl(__a, (unsigned char *)__b));
13834 }
13835 
13836 static __inline__ vector unsigned short __ATTRS_o_ai
13837 vec_lvlxl(int __a, const unsigned short *__b) {
13838  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
13839  vec_lvsl(__a, __b));
13840 }
13841 
13842 static __inline__ vector unsigned short __ATTRS_o_ai
13843 vec_lvlxl(int __a, const vector unsigned short *__b) {
13844  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
13845  vec_lvsl(__a, (unsigned char *)__b));
13846 }
13847 
13848 static __inline__ vector bool short __ATTRS_o_ai
13849 vec_lvlxl(int __a, const vector bool short *__b) {
13850  return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
13851  vec_lvsl(__a, (unsigned char *)__b));
13852 }
13853 
13854 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
13855  const vector pixel *__b) {
13856  return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
13857  vec_lvsl(__a, (unsigned char *)__b));
13858 }
13859 
13860 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
13861  return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
13862 }
13863 
13864 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
13865  const vector int *__b) {
13866  return vec_perm(vec_ldl(__a, __b), (vector int)(0),
13867  vec_lvsl(__a, (unsigned char *)__b));
13868 }
13869 
13870 static __inline__ vector unsigned int __ATTRS_o_ai
13871 vec_lvlxl(int __a, const unsigned int *__b) {
13872  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
13873  vec_lvsl(__a, __b));
13874 }
13875 
13876 static __inline__ vector unsigned int __ATTRS_o_ai
13877 vec_lvlxl(int __a, const vector unsigned int *__b) {
13878  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
13879  vec_lvsl(__a, (unsigned char *)__b));
13880 }
13881 
13882 static __inline__ vector bool int __ATTRS_o_ai
13883 vec_lvlxl(int __a, const vector bool int *__b) {
13884  return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
13885  vec_lvsl(__a, (unsigned char *)__b));
13886 }
13887 
13888 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
13889  const float *__b) {
13890  return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
13891 }
13892 
13893 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
13894  vector float *__b) {
13895  return vec_perm(vec_ldl(__a, __b), (vector float)(0),
13896  vec_lvsl(__a, (unsigned char *)__b));
13897 }
13898 
13899 /* vec_lvrx */
13900 
13901 static __inline__ vector signed char __ATTRS_o_ai
13902 vec_lvrx(int __a, const signed char *__b) {
13903  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
13904  vec_lvsl(__a, __b));
13905 }
13906 
13907 static __inline__ vector signed char __ATTRS_o_ai
13908 vec_lvrx(int __a, const vector signed char *__b) {
13909  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
13910  vec_lvsl(__a, (unsigned char *)__b));
13911 }
13912 
13913 static __inline__ vector unsigned char __ATTRS_o_ai
13914 vec_lvrx(int __a, const unsigned char *__b) {
13915  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
13916  vec_lvsl(__a, __b));
13917 }
13918 
13919 static __inline__ vector unsigned char __ATTRS_o_ai
13920 vec_lvrx(int __a, const vector unsigned char *__b) {
13921  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
13922  vec_lvsl(__a, (unsigned char *)__b));
13923 }
13924 
13925 static __inline__ vector bool char __ATTRS_o_ai
13926 vec_lvrx(int __a, const vector bool char *__b) {
13927  return vec_perm((vector bool char)(0), vec_ld(__a, __b),
13928  vec_lvsl(__a, (unsigned char *)__b));
13929 }
13930 
13931 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
13932  const short *__b) {
13933  return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13934 }
13935 
13936 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
13937  const vector short *__b) {
13938  return vec_perm((vector short)(0), vec_ld(__a, __b),
13939  vec_lvsl(__a, (unsigned char *)__b));
13940 }
13941 
13942 static __inline__ vector unsigned short __ATTRS_o_ai
13943 vec_lvrx(int __a, const unsigned short *__b) {
13944  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
13945  vec_lvsl(__a, __b));
13946 }
13947 
13948 static __inline__ vector unsigned short __ATTRS_o_ai
13949 vec_lvrx(int __a, const vector unsigned short *__b) {
13950  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
13951  vec_lvsl(__a, (unsigned char *)__b));
13952 }
13953 
13954 static __inline__ vector bool short __ATTRS_o_ai
13955 vec_lvrx(int __a, const vector bool short *__b) {
13956  return vec_perm((vector bool short)(0), vec_ld(__a, __b),
13957  vec_lvsl(__a, (unsigned char *)__b));
13958 }
13959 
13960 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
13961  const vector pixel *__b) {
13962  return vec_perm((vector pixel)(0), vec_ld(__a, __b),
13963  vec_lvsl(__a, (unsigned char *)__b));
13964 }
13965 
13966 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
13967  return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13968 }
13969 
13970 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
13971  const vector int *__b) {
13972  return vec_perm((vector int)(0), vec_ld(__a, __b),
13973  vec_lvsl(__a, (unsigned char *)__b));
13974 }
13975 
13976 static __inline__ vector unsigned int __ATTRS_o_ai
13977 vec_lvrx(int __a, const unsigned int *__b) {
13978  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13979  vec_lvsl(__a, __b));
13980 }
13981 
13982 static __inline__ vector unsigned int __ATTRS_o_ai
13983 vec_lvrx(int __a, const vector unsigned int *__b) {
13984  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13985  vec_lvsl(__a, (unsigned char *)__b));
13986 }
13987 
13988 static __inline__ vector bool int __ATTRS_o_ai
13989 vec_lvrx(int __a, const vector bool int *__b) {
13990  return vec_perm((vector bool int)(0), vec_ld(__a, __b),
13991  vec_lvsl(__a, (unsigned char *)__b));
13992 }
13993 
13994 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13995  const float *__b) {
13996  return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13997 }
13998 
13999 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
14000  const vector float *__b) {
14001  return vec_perm((vector float)(0), vec_ld(__a, __b),
14002  vec_lvsl(__a, (unsigned char *)__b));
14003 }
14004 
14005 /* vec_lvrxl */
14006 
14007 static __inline__ vector signed char __ATTRS_o_ai
14008 vec_lvrxl(int __a, const signed char *__b) {
14009  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
14010  vec_lvsl(__a, __b));
14011 }
14012 
14013 static __inline__ vector signed char __ATTRS_o_ai
14014 vec_lvrxl(int __a, const vector signed char *__b) {
14015  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
14016  vec_lvsl(__a, (unsigned char *)__b));
14017 }
14018 
14019 static __inline__ vector unsigned char __ATTRS_o_ai
14020 vec_lvrxl(int __a, const unsigned char *__b) {
14021  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
14022  vec_lvsl(__a, __b));
14023 }
14024 
14025 static __inline__ vector unsigned char __ATTRS_o_ai
14026 vec_lvrxl(int __a, const vector unsigned char *__b) {
14027  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
14028  vec_lvsl(__a, (unsigned char *)__b));
14029 }
14030 
14031 static __inline__ vector bool char __ATTRS_o_ai
14032 vec_lvrxl(int __a, const vector bool char *__b) {
14033  return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
14034  vec_lvsl(__a, (unsigned char *)__b));
14035 }
14036 
14037 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
14038  const short *__b) {
14039  return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14040 }
14041 
14042 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
14043  const vector short *__b) {
14044  return vec_perm((vector short)(0), vec_ldl(__a, __b),
14045  vec_lvsl(__a, (unsigned char *)__b));
14046 }
14047 
14048 static __inline__ vector unsigned short __ATTRS_o_ai
14049 vec_lvrxl(int __a, const unsigned short *__b) {
14050  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
14051  vec_lvsl(__a, __b));
14052 }
14053 
14054 static __inline__ vector unsigned short __ATTRS_o_ai
14055 vec_lvrxl(int __a, const vector unsigned short *__b) {
14056  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
14057  vec_lvsl(__a, (unsigned char *)__b));
14058 }
14059 
14060 static __inline__ vector bool short __ATTRS_o_ai
14061 vec_lvrxl(int __a, const vector bool short *__b) {
14062  return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
14063  vec_lvsl(__a, (unsigned char *)__b));
14064 }
14065 
14066 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
14067  const vector pixel *__b) {
14068  return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
14069  vec_lvsl(__a, (unsigned char *)__b));
14070 }
14071 
14072 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
14073  return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14074 }
14075 
14076 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
14077  const vector int *__b) {
14078  return vec_perm((vector int)(0), vec_ldl(__a, __b),
14079  vec_lvsl(__a, (unsigned char *)__b));
14080 }
14081 
14082 static __inline__ vector unsigned int __ATTRS_o_ai
14083 vec_lvrxl(int __a, const unsigned int *__b) {
14084  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
14085  vec_lvsl(__a, __b));
14086 }
14087 
14088 static __inline__ vector unsigned int __ATTRS_o_ai
14089 vec_lvrxl(int __a, const vector unsigned int *__b) {
14090  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
14091  vec_lvsl(__a, (unsigned char *)__b));
14092 }
14093 
14094 static __inline__ vector bool int __ATTRS_o_ai
14095 vec_lvrxl(int __a, const vector bool int *__b) {
14096  return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
14097  vec_lvsl(__a, (unsigned char *)__b));
14098 }
14099 
14100 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
14101  const float *__b) {
14102  return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14103 }
14104 
14105 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
14106  const vector float *__b) {
14107  return vec_perm((vector float)(0), vec_ldl(__a, __b),
14108  vec_lvsl(__a, (unsigned char *)__b));
14109 }
14110 
14111 /* vec_stvlx */
14112 
14113 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
14114  signed char *__c) {
14115  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14116  __c);
14117 }
14118 
14119 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
14120  vector signed char *__c) {
14121  return vec_st(
14122  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14123  __b, __c);
14124 }
14125 
14126 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
14127  unsigned char *__c) {
14128  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14129  __c);
14130 }
14131 
14132 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
14133  vector unsigned char *__c) {
14134  return vec_st(
14135  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14136  __b, __c);
14137 }
14138 
14139 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
14140  vector bool char *__c) {
14141  return vec_st(
14142  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14143  __b, __c);
14144 }
14145 
14146 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
14147  short *__c) {
14148  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14149  __c);
14150 }
14151 
14152 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
14153  vector short *__c) {
14154  return vec_st(
14155  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14156  __b, __c);
14157 }
14158 
14159 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
14160  int __b, unsigned short *__c) {
14161  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14162  __c);
14163 }
14164 
14165 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
14166  int __b,
14167  vector unsigned short *__c) {
14168  return vec_st(
14169  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14170  __b, __c);
14171 }
14172 
14173 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
14174  vector bool short *__c) {
14175  return vec_st(
14176  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14177  __b, __c);
14178 }
14179 
14180 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
14181  vector pixel *__c) {
14182  return vec_st(
14183  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14184  __b, __c);
14185 }
14186 
14187 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
14188  int *__c) {
14189  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14190  __c);
14191 }
14192 
14193 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
14194  vector int *__c) {
14195  return vec_st(
14196  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14197  __b, __c);
14198 }
14199 
14200 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
14201  unsigned int *__c) {
14202  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14203  __c);
14204 }
14205 
14206 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
14207  vector unsigned int *__c) {
14208  return vec_st(
14209  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14210  __b, __c);
14211 }
14212 
14213 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
14214  vector bool int *__c) {
14215  return vec_st(
14216  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14217  __b, __c);
14218 }
14219 
14220 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
14221  vector float *__c) {
14222  return vec_st(
14223  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14224  __b, __c);
14225 }
14226 
14227 /* vec_stvlxl */
14228 
14229 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
14230  signed char *__c) {
14231  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14232  __c);
14233 }
14234 
14235 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
14236  vector signed char *__c) {
14237  return vec_stl(
14238  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14239  __b, __c);
14240 }
14241 
14242 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
14243  int __b, unsigned char *__c) {
14244  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14245  __c);
14246 }
14247 
14248 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
14249  int __b,
14250  vector unsigned char *__c) {
14251  return vec_stl(
14252  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14253  __b, __c);
14254 }
14255 
14256 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
14257  vector bool char *__c) {
14258  return vec_stl(
14259  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14260  __b, __c);
14261 }
14262 
14263 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
14264  short *__c) {
14265  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14266  __c);
14267 }
14268 
14269 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
14270  vector short *__c) {
14271  return vec_stl(
14272  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14273  __b, __c);
14274 }
14275 
14276 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
14277  int __b, unsigned short *__c) {
14278  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14279  __c);
14280 }
14281 
14282 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
14283  int __b,
14284  vector unsigned short *__c) {
14285  return vec_stl(
14286  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14287  __b, __c);
14288 }
14289 
14290 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
14291  vector bool short *__c) {
14292  return vec_stl(
14293  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14294  __b, __c);
14295 }
14296 
14297 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
14298  vector pixel *__c) {
14299  return vec_stl(
14300  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14301  __b, __c);
14302 }
14303 
14304 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
14305  int *__c) {
14306  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14307  __c);
14308 }
14309 
14310 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
14311  vector int *__c) {
14312  return vec_stl(
14313  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14314  __b, __c);
14315 }
14316 
14317 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
14318  unsigned int *__c) {
14319  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14320  __c);
14321 }
14322 
14323 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
14324  vector unsigned int *__c) {
14325  return vec_stl(
14326  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14327  __b, __c);
14328 }
14329 
14330 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
14331  vector bool int *__c) {
14332  return vec_stl(
14333  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14334  __b, __c);
14335 }
14336 
14337 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
14338  vector float *__c) {
14339  return vec_stl(
14340  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14341  __b, __c);
14342 }
14343 
14344 /* vec_stvrx */
14345 
14346 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
14347  signed char *__c) {
14348  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14349  __c);
14350 }
14351 
14352 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
14353  vector signed char *__c) {
14354  return vec_st(
14355  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14356  __b, __c);
14357 }
14358 
14359 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
14360  unsigned char *__c) {
14361  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14362  __c);
14363 }
14364 
14365 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
14366  vector unsigned char *__c) {
14367  return vec_st(
14368  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14369  __b, __c);
14370 }
14371 
14372 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
14373  vector bool char *__c) {
14374  return vec_st(
14375  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14376  __b, __c);
14377 }
14378 
14379 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
14380  short *__c) {
14381  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14382  __c);
14383 }
14384 
14385 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
14386  vector short *__c) {
14387  return vec_st(
14388  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14389  __b, __c);
14390 }
14391 
14392 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
14393  int __b, unsigned short *__c) {
14394  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14395  __c);
14396 }
14397 
14398 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
14399  int __b,
14400  vector unsigned short *__c) {
14401  return vec_st(
14402  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14403  __b, __c);
14404 }
14405 
14406 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
14407  vector bool short *__c) {
14408  return vec_st(
14409  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14410  __b, __c);
14411 }
14412 
14413 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
14414  vector pixel *__c) {
14415  return vec_st(
14416  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14417  __b, __c);
14418 }
14419 
14420 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
14421  int *__c) {
14422  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14423  __c);
14424 }
14425 
14426 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
14427  vector int *__c) {
14428  return vec_st(
14429  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14430  __b, __c);
14431 }
14432 
14433 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
14434  unsigned int *__c) {
14435  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14436  __c);
14437 }
14438 
14439 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
14440  vector unsigned int *__c) {
14441  return vec_st(
14442  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14443  __b, __c);
14444 }
14445 
14446 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
14447  vector bool int *__c) {
14448  return vec_st(
14449  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14450  __b, __c);
14451 }
14452 
14453 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
14454  vector float *__c) {
14455  return vec_st(
14456  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14457  __b, __c);
14458 }
14459 
14460 /* vec_stvrxl */
14461 
14462 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
14463  signed char *__c) {
14464  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14465  __c);
14466 }
14467 
14468 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
14469  vector signed char *__c) {
14470  return vec_stl(
14471  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14472  __b, __c);
14473 }
14474 
14475 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
14476  int __b, unsigned char *__c) {
14477  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14478  __c);
14479 }
14480 
14481 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
14482  int __b,
14483  vector unsigned char *__c) {
14484  return vec_stl(
14485  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14486  __b, __c);
14487 }
14488 
14489 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
14490  vector bool char *__c) {
14491  return vec_stl(
14492  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14493  __b, __c);
14494 }
14495 
14496 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
14497  short *__c) {
14498  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14499  __c);
14500 }
14501 
14502 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
14503  vector short *__c) {
14504  return vec_stl(
14505  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14506  __b, __c);
14507 }
14508 
14509 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
14510  int __b, unsigned short *__c) {
14511  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14512  __c);
14513 }
14514 
14515 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
14516  int __b,
14517  vector unsigned short *__c) {
14518  return vec_stl(
14519  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14520  __b, __c);
14521 }
14522 
14523 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
14524  vector bool short *__c) {
14525  return vec_stl(
14526  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14527  __b, __c);
14528 }
14529 
14530 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
14531  vector pixel *__c) {
14532  return vec_stl(
14533  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14534  __b, __c);
14535 }
14536 
14537 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
14538  int *__c) {
14539  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14540  __c);
14541 }
14542 
14543 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
14544  vector int *__c) {
14545  return vec_stl(
14546  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14547  __b, __c);
14548 }
14549 
14550 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
14551  unsigned int *__c) {
14552  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14553  __c);
14554 }
14555 
14556 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
14557  vector unsigned int *__c) {
14558  return vec_stl(
14559  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14560  __b, __c);
14561 }
14562 
14563 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
14564  vector bool int *__c) {
14565  return vec_stl(
14566  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14567  __b, __c);
14568 }
14569 
14570 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
14571  vector float *__c) {
14572  return vec_stl(
14573  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14574  __b, __c);
14575 }
14576 
14577 /* vec_promote */
14578 
14579 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
14580  int __b) {
14581  vector signed char __res = (vector signed char)(0);
14582  __res[__b & 0x7] = __a;
14583  return __res;
14584 }
14585 
14586 static __inline__ vector unsigned char __ATTRS_o_ai
14587 vec_promote(unsigned char __a, int __b) {
14588  vector unsigned char __res = (vector unsigned char)(0);
14589  __res[__b & 0x7] = __a;
14590  return __res;
14591 }
14592 
14593 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
14594  vector short __res = (vector short)(0);
14595  __res[__b & 0x7] = __a;
14596  return __res;
14597 }
14598 
14599 static __inline__ vector unsigned short __ATTRS_o_ai
14600 vec_promote(unsigned short __a, int __b) {
14601  vector unsigned short __res = (vector unsigned short)(0);
14602  __res[__b & 0x7] = __a;
14603  return __res;
14604 }
14605 
14606 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
14607  vector int __res = (vector int)(0);
14608  __res[__b & 0x3] = __a;
14609  return __res;
14610 }
14611 
14612 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
14613  int __b) {
14614  vector unsigned int __res = (vector unsigned int)(0);
14615  __res[__b & 0x3] = __a;
14616  return __res;
14617 }
14618 
14619 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
14620  vector float __res = (vector float)(0);
14621  __res[__b & 0x3] = __a;
14622  return __res;
14623 }
14624 
14625 #ifdef __VSX__
14626 static __inline__ vector double __ATTRS_o_ai vec_promote(double __a, int __b) {
14627  vector double __res = (vector double)(0);
14628  __res[__b & 0x1] = __a;
14629  return __res;
14630 }
14631 
14632 static __inline__ vector signed long long __ATTRS_o_ai
14633 vec_promote(signed long long __a, int __b) {
14634  vector signed long long __res = (vector signed long long)(0);
14635  __res[__b & 0x1] = __a;
14636  return __res;
14637 }
14638 
14639 static __inline__ vector unsigned long long __ATTRS_o_ai
14640 vec_promote(unsigned long long __a, int __b) {
14641  vector unsigned long long __res = (vector unsigned long long)(0);
14642  __res[__b & 0x1] = __a;
14643  return __res;
14644 }
14645 #endif
14646 
14647 /* vec_splats */
14648 
14649 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
14650  return (vector signed char)(__a);
14651 }
14652 
14653 static __inline__ vector unsigned char __ATTRS_o_ai
14654 vec_splats(unsigned char __a) {
14655  return (vector unsigned char)(__a);
14656 }
14657 
14658 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
14659  return (vector short)(__a);
14660 }
14661 
14662 static __inline__ vector unsigned short __ATTRS_o_ai
14663 vec_splats(unsigned short __a) {
14664  return (vector unsigned short)(__a);
14665 }
14666 
14667 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
14668  return (vector int)(__a);
14669 }
14670 
14671 static __inline__ vector unsigned int __ATTRS_o_ai
14672 vec_splats(unsigned int __a) {
14673  return (vector unsigned int)(__a);
14674 }
14675 
14676 #ifdef __VSX__
14677 static __inline__ vector signed long long __ATTRS_o_ai
14678 vec_splats(signed long long __a) {
14679  return (vector signed long long)(__a);
14680 }
14681 
14682 static __inline__ vector unsigned long long __ATTRS_o_ai
14683 vec_splats(unsigned long long __a) {
14684  return (vector unsigned long long)(__a);
14685 }
14686 
14687 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
14688  defined(__SIZEOF_INT128__)
14689 static __inline__ vector signed __int128 __ATTRS_o_ai
14690 vec_splats(signed __int128 __a) {
14691  return (vector signed __int128)(__a);
14692 }
14693 
14694 static __inline__ vector unsigned __int128 __ATTRS_o_ai
14695 vec_splats(unsigned __int128 __a) {
14696  return (vector unsigned __int128)(__a);
14697 }
14698 
14699 #endif
14700 
14701 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
14702  return (vector double)(__a);
14703 }
14704 #endif
14705 
14706 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
14707  return (vector float)(__a);
14708 }
14709 
14710 /* ----------------------------- predicates --------------------------------- */
14711 
14712 /* vec_all_eq */
14713 
14714 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
14715  vector signed char __b) {
14716  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14717  (vector char)__b);
14718 }
14719 
14720 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
14721  vector bool char __b) {
14722  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14723  (vector char)__b);
14724 }
14725 
14726 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
14727  vector unsigned char __b) {
14728  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14729  (vector char)__b);
14730 }
14731 
14732 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
14733  vector bool char __b) {
14734  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14735  (vector char)__b);
14736 }
14737 
14738 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14739  vector signed char __b) {
14740  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14741  (vector char)__b);
14742 }
14743 
14744 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14745  vector unsigned char __b) {
14746  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14747  (vector char)__b);
14748 }
14749 
14750 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14751  vector bool char __b) {
14752  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14753  (vector char)__b);
14754 }
14755 
14756 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
14757  vector short __b) {
14758  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
14759 }
14760 
14761 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
14762  vector bool short __b) {
14763  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
14764 }
14765 
14766 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
14767  vector unsigned short __b) {
14768  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14769  (vector short)__b);
14770 }
14771 
14772 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
14773  vector bool short __b) {
14774  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14775  (vector short)__b);
14776 }
14777 
14778 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14779  vector short __b) {
14780  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14781  (vector short)__b);
14782 }
14783 
14784 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14785  vector unsigned short __b) {
14786  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14787  (vector short)__b);
14788 }
14789 
14790 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14791  vector bool short __b) {
14792  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14793  (vector short)__b);
14794 }
14795 
14796 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
14797  vector pixel __b) {
14798  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14799  (vector short)__b);
14800 }
14801 
14802 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
14803  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
14804 }
14805 
14806 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
14807  vector bool int __b) {
14808  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
14809 }
14810 
14811 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
14812  vector unsigned int __b) {
14813  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14814  (vector int)__b);
14815 }
14816 
14817 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
14818  vector bool int __b) {
14819  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14820  (vector int)__b);
14821 }
14822 
14823 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14824  vector int __b) {
14825  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14826  (vector int)__b);
14827 }
14828 
14829 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14830  vector unsigned int __b) {
14831  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14832  (vector int)__b);
14833 }
14834 
14835 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14836  vector bool int __b) {
14837  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14838  (vector int)__b);
14839 }
14840 
14841 #ifdef __VSX__
14842 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
14843  vector signed long long __b) {
14844 #ifdef __POWER8_VECTOR__
14845  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
14846 #else
14847  // No vcmpequd on Power7 so we xor the two vectors and compare against zero as
14848  // 32-bit elements.
14849  return vec_all_eq((vector signed int)vec_xor(__a, __b), (vector signed int)0);
14850 #endif
14851 }
14852 
14853 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
14854  vector bool long long __b) {
14855  return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14856 }
14857 
14858 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
14859  vector unsigned long long __b) {
14860  return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14861 }
14862 
14863 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
14864  vector bool long long __b) {
14865  return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14866 }
14867 
14868 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14869  vector long long __b) {
14870  return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14871 }
14872 
14873 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14874  vector unsigned long long __b) {
14875  return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14876 }
14877 
14878 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14879  vector bool long long __b) {
14880  return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14881 }
14882 #endif
14883 
14884 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
14885  vector float __b) {
14886 #ifdef __VSX__
14887  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
14888 #else
14889  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
14890 #endif
14891 }
14892 
14893 #ifdef __VSX__
14894 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
14895  vector double __b) {
14896  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
14897 }
14898 #endif
14899 
14900 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
14901 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed __int128 __a,
14902  vector signed __int128 __b) {
14903  return __builtin_altivec_vcmpequq_p(__CR6_LT, __a, __b);
14904 }
14905 
14906 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned __int128 __a,
14907  vector unsigned __int128 __b) {
14908  return __builtin_altivec_vcmpequq_p(__CR6_LT, __a, __b);
14909 }
14910 
14911 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool __int128 __a,
14912  vector bool __int128 __b) {
14913  return __builtin_altivec_vcmpequq_p(__CR6_LT, __a, __b);
14914 }
14915 #endif
14916 
14917 /* vec_all_ge */
14918 
14919 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
14920  vector signed char __b) {
14921  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
14922 }
14923 
14924 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
14925  vector bool char __b) {
14926  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
14927 }
14928 
14929 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
14930  vector unsigned char __b) {
14931  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
14932 }
14933 
14934 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
14935  vector bool char __b) {
14936  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
14937 }
14938 
14939 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
14940  vector signed char __b) {
14941  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, (vector signed char)__a);
14942 }
14943 
14944 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
14945  vector unsigned char __b) {
14946  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
14947 }
14948 
14949 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
14950  vector bool char __b) {
14951  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
14952  (vector unsigned char)__a);
14953 }
14954 
14955 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
14956  vector short __b) {
14957  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
14958 }
14959 
14960 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
14961  vector bool short __b) {
14962  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
14963 }
14964 
14965 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
14966  vector unsigned short __b) {
14967  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
14968 }
14969 
14970 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
14971  vector bool short __b) {
14972  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
14973  __a);
14974 }
14975 
14976 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
14977  vector short __b) {
14978  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, (vector signed short)__a);
14979 }
14980 
14981 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
14982  vector unsigned short __b) {
14983  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
14984  (vector unsigned short)__a);
14985 }
14986 
14987 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
14988  vector bool short __b) {
14989  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
14990  (vector unsigned short)__a);
14991 }
14992 
14993 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
14994  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
14995 }
14996 
14997 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
14998  vector bool int __b) {
14999  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
15000 }
15001 
15002 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
15003  vector unsigned int __b) {
15004  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
15005 }
15006 
15007 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
15008  vector bool int __b) {
15009  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
15010 }
15011 
15012 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
15013  vector int __b) {
15014  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, (vector signed int)__a);
15015 }
15016 
15017 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
15018  vector unsigned int __b) {
15019  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
15020 }
15021 
15022 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
15023  vector bool int __b) {
15024  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
15025  (vector unsigned int)__a);
15026 }
15027 
15028 #ifdef __VSX__
15029 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
15030  vector signed long long __b) {
15031  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
15032 }
15033 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
15034  vector bool long long __b) {
15035  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
15036  __a);
15037 }
15038 
15039 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
15040  vector unsigned long long __b) {
15041  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
15042 }
15043 
15044 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
15045  vector bool long long __b) {
15046  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
15047  __a);
15048 }
15049 
15050 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15051  vector signed long long __b) {
15052  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b,
15053  (vector signed long long)__a);
15054 }
15055 
15056 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15057  vector unsigned long long __b) {
15058  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
15059  (vector unsigned long long)__a);
15060 }
15061 
15062 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15063  vector bool long long __b) {
15064  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
15065  (vector unsigned long long)__a);
15066 }
15067 #endif
15068 
15069 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
15070  vector float __b) {
15071 #ifdef __VSX__
15072  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
15073 #else
15074  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
15075 #endif
15076 }
15077 
15078 #ifdef __VSX__
15079 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
15080  vector double __b) {
15081  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
15082 }
15083 #endif
15084 
15085 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15086 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed __int128 __a,
15087  vector signed __int128 __b) {
15088  return __builtin_altivec_vcmpgtsq_p(__CR6_EQ, __b, __a);
15089 }
15090 
15091 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned __int128 __a,
15092  vector unsigned __int128 __b) {
15093  return __builtin_altivec_vcmpgtuq_p(__CR6_EQ, __b, __a);
15094 }
15095 #endif
15096 
15097 /* vec_all_gt */
15098 
15099 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
15100  vector signed char __b) {
15101  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
15102 }
15103 
15104 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
15105  vector bool char __b) {
15106  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
15107 }
15108 
15109 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
15110  vector unsigned char __b) {
15111  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
15112 }
15113 
15114 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
15115  vector bool char __b) {
15116  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
15117 }
15118 
15119 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15120  vector signed char __b) {
15121  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__a, __b);
15122 }
15123 
15124 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15125  vector unsigned char __b) {
15126  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
15127 }
15128 
15129 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15130  vector bool char __b) {
15131  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
15132  (vector unsigned char)__b);
15133 }
15134 
15135 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
15136  vector short __b) {
15137  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
15138 }
15139 
15140 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
15141  vector bool short __b) {
15142  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
15143 }
15144 
15145 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
15146  vector unsigned short __b) {
15147  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
15148 }
15149 
15150 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
15151  vector bool short __b) {
15152  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
15153  (vector unsigned short)__b);
15154 }
15155 
15156 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15157  vector short __b) {
15158  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector signed short)__a, __b);
15159 }
15160 
15161 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15162  vector unsigned short __b) {
15163  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
15164  __b);
15165 }
15166 
15167 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15168  vector bool short __b) {
15169  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
15170  (vector unsigned short)__b);
15171 }
15172 
15173 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
15174  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
15175 }
15176 
15177 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
15178  vector bool int __b) {
15179  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
15180 }
15181 
15182 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
15183  vector unsigned int __b) {
15184  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
15185 }
15186 
15187 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
15188  vector bool int __b) {
15189  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
15190 }
15191 
15192 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15193  vector int __b) {
15194  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector signed int)__a, __b);
15195 }
15196 
15197 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15198  vector unsigned int __b) {
15199  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
15200 }
15201 
15202 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15203  vector bool int __b) {
15204  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
15205  (vector unsigned int)__b);
15206 }
15207 
15208 #ifdef __VSX__
15209 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
15210  vector signed long long __b) {
15211  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
15212 }
15213 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
15214  vector bool long long __b) {
15215  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
15216  (vector signed long long)__b);
15217 }
15218 
15219 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
15220  vector unsigned long long __b) {
15221  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
15222 }
15223 
15224 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
15225  vector bool long long __b) {
15226  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
15227  (vector unsigned long long)__b);
15228 }
15229 
15230 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15231  vector signed long long __b) {
15232  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__a,
15233  __b);
15234 }
15235 
15236 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15237  vector unsigned long long __b) {
15238  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
15239  __b);
15240 }
15241 
15242 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15243  vector bool long long __b) {
15244  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
15245  (vector unsigned long long)__b);
15246 }
15247 #endif
15248 
15249 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
15250  vector float __b) {
15251 #ifdef __VSX__
15252  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
15253 #else
15254  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
15255 #endif
15256 }
15257 
15258 #ifdef __VSX__
15259 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
15260  vector double __b) {
15261  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
15262 }
15263 #endif
15264 
15265 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15266 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed __int128 __a,
15267  vector signed __int128 __b) {
15268  return __builtin_altivec_vcmpgtsq_p(__CR6_LT, __a, __b);
15269 }
15270 
15271 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned __int128 __a,
15272  vector unsigned __int128 __b) {
15273  return __builtin_altivec_vcmpgtuq_p(__CR6_LT, __a, __b);
15274 }
15275 #endif
15276 
15277 /* vec_all_in */
15278 
15279 static __inline__ int __attribute__((__always_inline__))
15280 vec_all_in(vector float __a, vector float __b) {
15281  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
15282 }
15283 
15284 /* vec_all_le */
15285 
15286 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
15287  vector signed char __b) {
15288  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
15289 }
15290 
15291 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
15292  vector bool char __b) {
15293  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
15294 }
15295 
15296 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
15297  vector unsigned char __b) {
15298  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
15299 }
15300 
15301 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
15302  vector bool char __b) {
15303  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
15304 }
15305 
15306 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15307  vector signed char __b) {
15308  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__a, __b);
15309 }
15310 
15311 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15312  vector unsigned char __b) {
15313  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
15314 }
15315 
15316 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15317  vector bool char __b) {
15318  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
15319  (vector unsigned char)__b);
15320 }
15321 
15322 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
15323  vector short __b) {
15324  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
15325 }
15326 
15327 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
15328  vector bool short __b) {
15329  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
15330 }
15331 
15332 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
15333  vector unsigned short __b) {
15334  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
15335 }
15336 
15337 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
15338  vector bool short __b) {
15339  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
15340  (vector unsigned short)__b);
15341 }
15342 
15343 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15344  vector short __b) {
15345  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector signed short)__a, __b);
15346 }
15347 
15348 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15349  vector unsigned short __b) {
15350  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
15351  __b);
15352 }
15353 
15354 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15355  vector bool short __b) {
15356  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
15357  (vector unsigned short)__b);
15358 }
15359 
15360 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
15361  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
15362 }
15363 
15364 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
15365  vector bool int __b) {
15366  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
15367 }
15368 
15369 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
15370  vector unsigned int __b) {
15371  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
15372 }
15373 
15374 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
15375  vector bool int __b) {
15376  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
15377 }
15378 
15379 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15380  vector int __b) {
15381  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector signed int)__a, __b);
15382 }
15383 
15384 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15385  vector unsigned int __b) {
15386  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
15387 }
15388 
15389 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15390  vector bool int __b) {
15391  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
15392  (vector unsigned int)__b);
15393 }
15394 
15395 #ifdef __VSX__
15396 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
15397  vector signed long long __b) {
15398  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
15399 }
15400 
15401 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
15402  vector unsigned long long __b) {
15403  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
15404 }
15405 
15406 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
15407  vector bool long long __b) {
15408  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
15409  (vector signed long long)__b);
15410 }
15411 
15412 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
15413  vector bool long long __b) {
15414  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
15415  (vector unsigned long long)__b);
15416 }
15417 
15418 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15419  vector signed long long __b) {
15420  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__a,
15421  __b);
15422 }
15423 
15424 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15425  vector unsigned long long __b) {
15426  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
15427  __b);
15428 }
15429 
15430 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15431  vector bool long long __b) {
15432  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
15433  (vector unsigned long long)__b);
15434 }
15435 #endif
15436 
15437 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
15438  vector float __b) {
15439 #ifdef __VSX__
15440  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
15441 #else
15442  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
15443 #endif
15444 }
15445 
15446 #ifdef __VSX__
15447 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
15448  vector double __b) {
15449  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
15450 }
15451 #endif
15452 
15453 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15454 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed __int128 __a,
15455  vector signed __int128 __b) {
15456  return __builtin_altivec_vcmpgtsq_p(__CR6_EQ, __a, __b);
15457 }
15458 
15459 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned __int128 __a,
15460  vector unsigned __int128 __b) {
15461  return __builtin_altivec_vcmpgtuq_p(__CR6_EQ, __a, __b);
15462 }
15463 #endif
15464 
15465 /* vec_all_lt */
15466 
15467 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
15468  vector signed char __b) {
15469  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
15470 }
15471 
15472 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
15473  vector bool char __b) {
15474  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
15475 }
15476 
15477 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
15478  vector unsigned char __b) {
15479  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
15480 }
15481 
15482 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
15483  vector bool char __b) {
15484  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
15485 }
15486 
15487 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15488  vector signed char __b) {
15489  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, (vector signed char)__a);
15490 }
15491 
15492 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15493  vector unsigned char __b) {
15494  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
15495 }
15496 
15497 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15498  vector bool char __b) {
15499  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
15500  (vector unsigned char)__a);
15501 }
15502 
15503 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
15504  vector short __b) {
15505  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
15506 }
15507 
15508 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
15509  vector bool short __b) {
15510  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
15511 }
15512 
15513 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
15514  vector unsigned short __b) {
15515  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
15516 }
15517 
15518 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
15519  vector bool short __b) {
15520  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
15521  __a);
15522 }
15523 
15524 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15525  vector short __b) {
15526  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, (vector signed short)__a);
15527 }
15528 
15529 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15530  vector unsigned short __b) {
15531  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
15532  (vector unsigned short)__a);
15533 }
15534 
15535 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15536  vector bool short __b) {
15537  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
15538  (vector unsigned short)__a);
15539 }
15540 
15541 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
15542  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
15543 }
15544 
15545 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
15546  vector bool int __b) {
15547  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
15548 }
15549 
15550 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
15551  vector unsigned int __b) {
15552  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
15553 }
15554 
15555 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
15556  vector bool int __b) {
15557  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
15558 }
15559 
15560 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15561  vector int __b) {
15562  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, (vector signed int)__a);
15563 }
15564 
15565 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15566  vector unsigned int __b) {
15567  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
15568 }
15569 
15570 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15571  vector bool int __b) {
15572  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
15573  (vector unsigned int)__a);
15574 }
15575 
15576 #ifdef __VSX__
15577 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
15578  vector signed long long __b) {
15579  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
15580 }
15581 
15582 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
15583  vector unsigned long long __b) {
15584  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
15585 }
15586 
15587 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
15588  vector bool long long __b) {
15589  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
15590  __a);
15591 }
15592 
15593 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
15594  vector bool long long __b) {
15595  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
15596  __a);
15597 }
15598 
15599 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15600  vector signed long long __b) {
15601  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b,
15602  (vector signed long long)__a);
15603 }
15604 
15605 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15606  vector unsigned long long __b) {
15607  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
15608  (vector unsigned long long)__a);
15609 }
15610 
15611 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15612  vector bool long long __b) {
15613  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
15614  (vector unsigned long long)__a);
15615 }
15616 #endif
15617 
15618 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
15619  vector float __b) {
15620 #ifdef __VSX__
15621  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
15622 #else
15623  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
15624 #endif
15625 }
15626 
15627 #ifdef __VSX__
15628 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
15629  vector double __b) {
15630  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
15631 }
15632 #endif
15633 
15634 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15635 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed __int128 __a,
15636  vector signed __int128 __b) {
15637  return __builtin_altivec_vcmpgtsq_p(__CR6_LT, __b, __a);
15638 }
15639 
15640 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned __int128 __a,
15641  vector unsigned __int128 __b) {
15642  return __builtin_altivec_vcmpgtuq_p(__CR6_LT, __b, __a);
15643 }
15644 #endif
15645 
15646 /* vec_all_nan */
15647 
15648 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
15649 #ifdef __VSX__
15650  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
15651 #else
15652  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
15653 #endif
15654 }
15655 
15656 #ifdef __VSX__
15657 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
15658  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
15659 }
15660 #endif
15661 
15662 /* vec_all_ne */
15663 
15664 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
15665  vector signed char __b) {
15666  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15667  (vector char)__b);
15668 }
15669 
15670 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
15671  vector bool char __b) {
15672  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15673  (vector char)__b);
15674 }
15675 
15676 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
15677  vector unsigned char __b) {
15678  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15679  (vector char)__b);
15680 }
15681 
15682 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
15683  vector bool char __b) {
15684  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15685  (vector char)__b);
15686 }
15687 
15688 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15689  vector signed char __b) {
15690  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15691  (vector char)__b);
15692 }
15693 
15694 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15695  vector unsigned char __b) {
15696  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15697  (vector char)__b);
15698 }
15699 
15700 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15701  vector bool char __b) {
15702  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15703  (vector char)__b);
15704 }
15705 
15706 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
15707  vector short __b) {
15708  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
15709 }
15710 
15711 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
15712  vector bool short __b) {
15713  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
15714 }
15715 
15716 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
15717  vector unsigned short __b) {
15718  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15719  (vector short)__b);
15720 }
15721 
15722 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
15723  vector bool short __b) {
15724  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15725  (vector short)__b);
15726 }
15727 
15728 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15729  vector short __b) {
15730  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15731  (vector short)__b);
15732 }
15733 
15734 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15735  vector unsigned short __b) {
15736  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15737  (vector short)__b);
15738 }
15739 
15740 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15741  vector bool short __b) {
15742  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15743  (vector short)__b);
15744 }
15745 
15746 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
15747  vector pixel __b) {
15748  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15749  (vector short)__b);
15750 }
15751 
15752 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
15753  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
15754 }
15755 
15756 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
15757  vector bool int __b) {
15758  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
15759 }
15760 
15761 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
15762  vector unsigned int __b) {
15763  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15764  (vector int)__b);
15765 }
15766 
15767 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
15768  vector bool int __b) {
15769  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15770  (vector int)__b);
15771 }
15772 
15773 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15774  vector int __b) {
15775  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15776  (vector int)__b);
15777 }
15778 
15779 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15780  vector unsigned int __b) {
15781  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15782  (vector int)__b);
15783 }
15784 
15785 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15786  vector bool int __b) {
15787  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15788  (vector int)__b);
15789 }
15790 
15791 #ifdef __VSX__
15792 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
15793  vector signed long long __b) {
15794  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
15795 }
15796 
15797 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
15798  vector unsigned long long __b) {
15799  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
15800  (vector long long)__b);
15801 }
15802 
15803 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
15804  vector bool long long __b) {
15805  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
15806  (vector signed long long)__b);
15807 }
15808 
15809 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
15810  vector bool long long __b) {
15811  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15812  (vector signed long long)__b);
15813 }
15814 
15815 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15816  vector signed long long __b) {
15817  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15818  (vector signed long long)__b);
15819 }
15820 
15821 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15822  vector unsigned long long __b) {
15823  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15824  (vector signed long long)__b);
15825 }
15826 
15827 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15828  vector bool long long __b) {
15829  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15830  (vector signed long long)__b);
15831 }
15832 #endif
15833 
15834 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
15835  vector float __b) {
15836 #ifdef __VSX__
15837  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __b);
15838 #else
15839  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
15840 #endif
15841 }
15842 
15843 #ifdef __VSX__
15844 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
15845  vector double __b) {
15846  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
15847 }
15848 #endif
15849 
15850 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15851 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed __int128 __a,
15852  vector signed __int128 __b) {
15853  return __builtin_altivec_vcmpequq_p(__CR6_EQ, __a, __b);
15854 }
15855 
15856 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned __int128 __a,
15857  vector unsigned __int128 __b) {
15858  return __builtin_altivec_vcmpequq_p(__CR6_EQ, __a, __b);
15859 }
15860 
15861 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool __int128 __a,
15862  vector bool __int128 __b) {
15863  return __builtin_altivec_vcmpequq_p(__CR6_EQ, __a, __b);
15864 }
15865 #endif
15866 
15867 /* vec_all_nge */
15868 
15869 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
15870  vector float __b) {
15871 #ifdef __VSX__
15872  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
15873 #else
15874  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
15875 #endif
15876 }
15877 
15878 #ifdef __VSX__
15879 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
15880  vector double __b) {
15881  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
15882 }
15883 #endif
15884 
15885 /* vec_all_ngt */
15886 
15887 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
15888  vector float __b) {
15889 #ifdef __VSX__
15890  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
15891 #else
15892  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
15893 #endif
15894 }
15895 
15896 #ifdef __VSX__
15897 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
15898  vector double __b) {
15899  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
15900 }
15901 #endif
15902 
15903 /* vec_all_nle */
15904 
15905 static __inline__ int __ATTRS_o_ai
15906 vec_all_nle(vector float __a, vector float __b) {
15907 #ifdef __VSX__
15908  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __b, __a);
15909 #else
15910  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
15911 #endif
15912 }
15913 
15914 #ifdef __VSX__
15915 static __inline__ int __ATTRS_o_ai vec_all_nle(vector double __a,
15916  vector double __b) {
15917  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __b, __a);
15918 }
15919 #endif
15920 
15921 /* vec_all_nlt */
15922 
15923 static __inline__ int __ATTRS_o_ai
15924 vec_all_nlt(vector float __a, vector float __b) {
15925 #ifdef __VSX__
15926  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __b, __a);
15927 #else
15928  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
15929 #endif
15930 }
15931 
15932 #ifdef __VSX__
15933 static __inline__ int __ATTRS_o_ai vec_all_nlt(vector double __a,
15934  vector double __b) {
15935  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __b, __a);
15936 }
15937 #endif
15938 
15939 /* vec_all_numeric */
15940 
15941 static __inline__ int __ATTRS_o_ai
15942 vec_all_numeric(vector float __a) {
15943 #ifdef __VSX__
15944  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __a);
15945 #else
15946  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
15947 #endif
15948 }
15949 
15950 #ifdef __VSX__
15951 static __inline__ int __ATTRS_o_ai vec_all_numeric(vector double __a) {
15952  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __a);
15953 }
15954 #endif
15955 
15956 /* vec_any_eq */
15957 
15958 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
15959  vector signed char __b) {
15960  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15961  (vector char)__b);
15962 }
15963 
15964 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
15965  vector bool char __b) {
15966  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15967  (vector char)__b);
15968 }
15969 
15970 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
15971  vector unsigned char __b) {
15972  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15973  (vector char)__b);
15974 }
15975 
15976 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
15977  vector bool char __b) {
15978  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15979  (vector char)__b);
15980 }
15981 
15982 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
15983  vector signed char __b) {
15984  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15985  (vector char)__b);
15986 }
15987 
15988 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
15989  vector unsigned char __b) {
15990  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15991  (vector char)__b);
15992 }
15993 
15994 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
15995  vector bool char __b) {
15996  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15997  (vector char)__b);
15998 }
15999 
16000 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
16001  vector short __b) {
16002  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
16003 }
16004 
16005 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
16006  vector bool short __b) {
16007  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
16008 }
16009 
16010 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
16011  vector unsigned short __b) {
16012  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16013  (vector short)__b);
16014 }
16015 
16016 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
16017  vector bool short __b) {
16018  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16019  (vector short)__b);
16020 }
16021 
16022 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
16023  vector short __b) {
16024  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16025  (vector short)__b);
16026 }
16027 
16028 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
16029  vector unsigned short __b) {
16030  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16031  (vector short)__b);
16032 }
16033 
16034 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
16035  vector bool short __b) {
16036  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16037  (vector short)__b);
16038 }
16039 
16040 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
16041  vector pixel __b) {
16042  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16043  (vector short)__b);
16044 }
16045 
16046 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
16047  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
16048 }
16049 
16050 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
16051  vector bool int __b) {
16052  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
16053 }
16054 
16055 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
16056  vector unsigned int __b) {
16057  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16058  (vector int)__b);
16059 }
16060 
16061 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
16062  vector bool int __b) {
16063  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16064  (vector int)__b);
16065 }
16066 
16067 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16068  vector int __b) {
16069  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16070  (vector int)__b);
16071 }
16072 
16073 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16074  vector unsigned int __b) {
16075  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16076  (vector int)__b);
16077 }
16078 
16079 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16080  vector bool int __b) {
16081  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16082  (vector int)__b);
16083 }
16084 
16085 #ifdef __VSX__
16086 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
16087  vector signed long long __b) {
16088  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
16089 }
16090 
16091 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
16092  vector unsigned long long __b) {
16093  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
16094  (vector long long)__b);
16095 }
16096 
16097 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
16098  vector bool long long __b) {
16099  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
16100  (vector signed long long)__b);
16101 }
16102 
16103 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
16104  vector bool long long __b) {
16105  return __builtin_altivec_vcmpequd_p(
16106  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16107 }
16108 
16109 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16110  vector signed long long __b) {
16111  return __builtin_altivec_vcmpequd_p(
16112  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16113 }
16114 
16115 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16116  vector unsigned long long __b) {
16117  return __builtin_altivec_vcmpequd_p(
16118  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16119 }
16120 
16121 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16122  vector bool long long __b) {
16123  return __builtin_altivec_vcmpequd_p(
16124  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16125 }
16126 #endif
16127 
16128 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
16129  vector float __b) {
16130 #ifdef __VSX__
16131  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
16132 #else
16133  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
16134 #endif
16135 }
16136 
16137 #ifdef __VSX__
16138 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
16139  vector double __b) {
16140  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
16141 }
16142 #endif
16143 
16144 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16145 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed __int128 __a,
16146  vector signed __int128 __b) {
16147  return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV, __a, __b);
16148 }
16149 
16150 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned __int128 __a,
16151  vector unsigned __int128 __b) {
16152  return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV, __a, __b);
16153 }
16154 
16155 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool __int128 __a,
16156  vector bool __int128 __b) {
16157  return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV, __a, __b);
16158 }
16159 #endif
16160 
16161 /* vec_any_ge */
16162 
16163 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
16164  vector signed char __b) {
16165  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
16166 }
16167 
16168 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
16169  vector bool char __b) {
16170  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
16171  __a);
16172 }
16173 
16174 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
16175  vector unsigned char __b) {
16176  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
16177 }
16178 
16179 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
16180  vector bool char __b) {
16181  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
16182  __a);
16183 }
16184 
16185 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16186  vector signed char __b) {
16187  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b,
16188  (vector signed char)__a);
16189 }
16190 
16191 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16192  vector unsigned char __b) {
16193  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
16194  (vector unsigned char)__a);
16195 }
16196 
16197 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16198  vector bool char __b) {
16199  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
16200  (vector unsigned char)__a);
16201 }
16202 
16203 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
16204  vector short __b) {
16205  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
16206 }
16207 
16208 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
16209  vector bool short __b) {
16210  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
16211 }
16212 
16213 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
16214  vector unsigned short __b) {
16215  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
16216 }
16217 
16218 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
16219  vector bool short __b) {
16220  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
16221  __a);
16222 }
16223 
16224 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16225  vector short __b) {
16226  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b,
16227  (vector signed short)__a);
16228 }
16229 
16230 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16231  vector unsigned short __b) {
16232  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
16233  (vector unsigned short)__a);
16234 }
16235 
16236 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16237  vector bool short __b) {
16238  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
16239  (vector unsigned short)__a);
16240 }
16241 
16242 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
16243  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
16244 }
16245 
16246 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
16247  vector bool int __b) {
16248  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
16249 }
16250 
16251 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
16252  vector unsigned int __b) {
16253  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
16254 }
16255 
16256 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
16257  vector bool int __b) {
16258  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
16259  __a);
16260 }
16261 
16262 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16263  vector int __b) {
16264  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b,
16265  (vector signed int)__a);
16266 }
16267 
16268 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16269  vector unsigned int __b) {
16270  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
16271  (vector unsigned int)__a);
16272 }
16273 
16274 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16275  vector bool int __b) {
16276  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
16277  (vector unsigned int)__a);
16278 }
16279 
16280 #ifdef __VSX__
16281 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
16282  vector signed long long __b) {
16283  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
16284 }
16285 
16286 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
16287  vector unsigned long long __b) {
16288  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
16289 }
16290 
16291 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
16292  vector bool long long __b) {
16293  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
16294  (vector signed long long)__b, __a);
16295 }
16296 
16297 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
16298  vector bool long long __b) {
16299  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16300  (vector unsigned long long)__b, __a);
16301 }
16302 
16303 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16304  vector signed long long __b) {
16305  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b,
16306  (vector signed long long)__a);
16307 }
16308 
16309 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16310  vector unsigned long long __b) {
16311  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
16312  (vector unsigned long long)__a);
16313 }
16314 
16315 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16316  vector bool long long __b) {
16317  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16318  (vector unsigned long long)__b,
16319  (vector unsigned long long)__a);
16320 }
16321 #endif
16322 
16323 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
16324  vector float __b) {
16325 #ifdef __VSX__
16326  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
16327 #else
16328  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
16329 #endif
16330 }
16331 
16332 #ifdef __VSX__
16333 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
16334  vector double __b) {
16335  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
16336 }
16337 #endif
16338 
16339 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16340 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed __int128 __a,
16341  vector signed __int128 __b) {
16342  return __builtin_altivec_vcmpgtsq_p(__CR6_LT_REV, __b, __a);
16343 }
16344 
16345 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned __int128 __a,
16346  vector unsigned __int128 __b) {
16347  return __builtin_altivec_vcmpgtuq_p(__CR6_LT_REV, __b, __a);
16348 }
16349 #endif
16350 
16351 /* vec_any_gt */
16352 
16353 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
16354  vector signed char __b) {
16355  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
16356 }
16357 
16358 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
16359  vector bool char __b) {
16360  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
16361  (vector signed char)__b);
16362 }
16363 
16364 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
16365  vector unsigned char __b) {
16366  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
16367 }
16368 
16369 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
16370  vector bool char __b) {
16371  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
16372  (vector unsigned char)__b);
16373 }
16374 
16375 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16376  vector signed char __b) {
16377  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__a,
16378  __b);
16379 }
16380 
16381 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16382  vector unsigned char __b) {
16383  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
16384  __b);
16385 }
16386 
16387 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16388  vector bool char __b) {
16389  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
16390  (vector unsigned char)__b);
16391 }
16392 
16393 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
16394  vector short __b) {
16395  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
16396 }
16397 
16398 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
16399  vector bool short __b) {
16400  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
16401 }
16402 
16403 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
16404  vector unsigned short __b) {
16405  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
16406 }
16407 
16408 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
16409  vector bool short __b) {
16410  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
16411  (vector unsigned short)__b);
16412 }
16413 
16414 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16415  vector short __b) {
16416  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector signed short)__a,
16417  __b);
16418 }
16419 
16420 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16421  vector unsigned short __b) {
16422  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
16423  __b);
16424 }
16425 
16426 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16427  vector bool short __b) {
16428  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
16429  (vector unsigned short)__b);
16430 }
16431 
16432 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
16433  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
16434 }
16435 
16436 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
16437  vector bool int __b) {
16438  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
16439 }
16440 
16441 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
16442  vector unsigned int __b) {
16443  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
16444 }
16445 
16446 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
16447  vector bool int __b) {
16448  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
16449  (vector unsigned int)__b);
16450 }
16451 
16452 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16453  vector int __b) {
16454  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector signed int)__a,
16455  __b);
16456 }
16457 
16458 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16459  vector unsigned int __b) {
16460  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
16461  __b);
16462 }
16463 
16464 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16465  vector bool int __b) {
16466  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
16467  (vector unsigned int)__b);
16468 }
16469 
16470 #ifdef __VSX__
16471 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
16472  vector signed long long __b) {
16473  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
16474 }
16475 
16476 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
16477  vector unsigned long long __b) {
16478  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
16479 }
16480 
16481 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
16482  vector bool long long __b) {
16483  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
16484  (vector signed long long)__b);
16485 }
16486 
16487 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
16488  vector bool long long __b) {
16489  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
16490  (vector unsigned long long)__b);
16491 }
16492 
16493 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16494  vector signed long long __b) {
16495  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
16496  (vector signed long long)__a, __b);
16497 }
16498 
16499 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16500  vector unsigned long long __b) {
16501  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16502  (vector unsigned long long)__a, __b);
16503 }
16504 
16505 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16506  vector bool long long __b) {
16507  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16508  (vector unsigned long long)__a,
16509  (vector unsigned long long)__b);
16510 }
16511 #endif
16512 
16513 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
16514  vector float __b) {
16515 #ifdef __VSX__
16516  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
16517 #else
16518  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
16519 #endif
16520 }
16521 
16522 #ifdef __VSX__
16523 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
16524  vector double __b) {
16525  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
16526 }
16527 #endif
16528 
16529 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16530 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed __int128 __a,
16531  vector signed __int128 __b) {
16532  return __builtin_altivec_vcmpgtsq_p(__CR6_EQ_REV, __a, __b);
16533 }
16534 
16535 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned __int128 __a,
16536  vector unsigned __int128 __b) {
16537  return __builtin_altivec_vcmpgtuq_p(__CR6_EQ_REV, __a, __b);
16538 }
16539 #endif
16540 
16541 /* vec_any_le */
16542 
16543 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
16544  vector signed char __b) {
16545  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
16546 }
16547 
16548 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
16549  vector bool char __b) {
16550  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
16551  (vector signed char)__b);
16552 }
16553 
16554 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
16555  vector unsigned char __b) {
16556  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
16557 }
16558 
16559 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
16560  vector bool char __b) {
16561  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
16562  (vector unsigned char)__b);
16563 }
16564 
16565 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16566  vector signed char __b) {
16567  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__a,
16568  __b);
16569 }
16570 
16571 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16572  vector unsigned char __b) {
16573  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
16574  __b);
16575 }
16576 
16577 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16578  vector bool char __b) {
16579  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
16580  (vector unsigned char)__b);
16581 }
16582 
16583 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
16584  vector short __b) {
16585  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
16586 }
16587 
16588 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
16589  vector bool short __b) {
16590  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
16591 }
16592 
16593 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
16594  vector unsigned short __b) {
16595  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
16596 }
16597 
16598 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
16599  vector bool short __b) {
16600  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
16601  (vector unsigned short)__b);
16602 }
16603 
16604 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16605  vector short __b) {
16606  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector signed short)__a,
16607  __b);
16608 }
16609 
16610 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16611  vector unsigned short __b) {
16612  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
16613  __b);
16614 }
16615 
16616 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16617  vector bool short __b) {
16618  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
16619  (vector unsigned short)__b);
16620 }
16621 
16622 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
16623  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
16624 }
16625 
16626 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
16627  vector bool int __b) {
16628  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
16629 }
16630 
16631 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
16632  vector unsigned int __b) {
16633  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
16634 }
16635 
16636 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
16637  vector bool int __b) {
16638  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
16639  (vector unsigned int)__b);
16640 }
16641 
16642 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16643  vector int __b) {
16644  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector signed int)__a,
16645  __b);
16646 }
16647 
16648 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16649  vector unsigned int __b) {
16650  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
16651  __b);
16652 }
16653 
16654 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16655  vector bool int __b) {
16656  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
16657  (vector unsigned int)__b);
16658 }
16659 
16660 #ifdef __VSX__
16661 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
16662  vector signed long long __b) {
16663  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
16664 }
16665 
16666 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
16667  vector unsigned long long __b) {
16668  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
16669 }
16670 
16671 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
16672  vector bool long long __b) {
16673  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
16674  (vector signed long long)__b);
16675 }
16676 
16677 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
16678  vector bool long long __b) {
16679  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
16680  (vector unsigned long long)__b);
16681 }
16682 
16683 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16684  vector signed long long __b) {
16685  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
16686  (vector signed long long)__a, __b);
16687 }
16688 
16689 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16690  vector unsigned long long __b) {
16691  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16692  (vector unsigned long long)__a, __b);
16693 }
16694 
16695 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16696  vector bool long long __b) {
16697  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16698  (vector unsigned long long)__a,
16699  (vector unsigned long long)__b);
16700 }
16701 #endif
16702 
16703 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
16704  vector float __b) {
16705 #ifdef __VSX__
16706  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
16707 #else
16708  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
16709 #endif
16710 }
16711 
16712 #ifdef __VSX__
16713 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
16714  vector double __b) {
16715  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
16716 }
16717 #endif
16718 
16719 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16720 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed __int128 __a,
16721  vector signed __int128 __b) {
16722  return __builtin_altivec_vcmpgtsq_p(__CR6_LT_REV, __a, __b);
16723 }
16724 
16725 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned __int128 __a,
16726  vector unsigned __int128 __b) {
16727  return __builtin_altivec_vcmpgtuq_p(__CR6_LT_REV, __a, __b);
16728 }
16729 #endif
16730 
16731 /* vec_any_lt */
16732 
16733 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
16734  vector signed char __b) {
16735  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
16736 }
16737 
16738 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
16739  vector bool char __b) {
16740  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
16741  __a);
16742 }
16743 
16744 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
16745  vector unsigned char __b) {
16746  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
16747 }
16748 
16749 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
16750  vector bool char __b) {
16751  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
16752  __a);
16753 }
16754 
16755 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16756  vector signed char __b) {
16757  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b,
16758  (vector signed char)__a);
16759 }
16760 
16761 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16762  vector unsigned char __b) {
16763  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
16764  (vector unsigned char)__a);
16765 }
16766 
16767 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16768  vector bool char __b) {
16769  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
16770  (vector unsigned char)__a);
16771 }
16772 
16773 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
16774  vector short __b) {
16775  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
16776 }
16777 
16778 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
16779  vector bool short __b) {
16780  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
16781 }
16782 
16783 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
16784  vector unsigned short __b) {
16785  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
16786 }
16787 
16788 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
16789  vector bool short __b) {
16790  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
16791  __a);
16792 }
16793 
16794 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16795  vector short __b) {
16796  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b,
16797  (vector signed short)__a);
16798 }
16799 
16800 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16801  vector unsigned short __b) {
16802  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
16803  (vector unsigned short)__a);
16804 }
16805 
16806 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16807  vector bool short __b) {
16808  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
16809  (vector unsigned short)__a);
16810 }
16811 
16812 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
16813  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
16814 }
16815 
16816 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
16817  vector bool int __b) {
16818  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
16819 }
16820 
16821 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
16822  vector unsigned int __b) {
16823  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
16824 }
16825 
16826 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
16827  vector bool int __b) {
16828  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
16829  __a);
16830 }
16831 
16832 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16833  vector int __b) {
16834  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b,
16835  (vector signed int)__a);
16836 }
16837 
16838 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16839  vector unsigned int __b) {
16840  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
16841  (vector unsigned int)__a);
16842 }
16843 
16844 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16845  vector bool int __b) {
16846  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
16847  (vector unsigned int)__a);
16848 }
16849 
16850 #ifdef __VSX__
16851 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
16852  vector signed long long __b) {
16853  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
16854 }
16855 
16856 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
16857  vector unsigned long long __b) {
16858  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
16859 }
16860 
16861 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
16862  vector bool long long __b) {
16863  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
16864  (vector signed long long)__b, __a);
16865 }
16866 
16867 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
16868  vector bool long long __b) {
16869  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16870  (vector unsigned long long)__b, __a);
16871 }
16872 
16873 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16874  vector signed long long __b) {
16875  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b,
16876  (vector signed long long)__a);
16877 }
16878 
16879 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16880  vector unsigned long long __b) {
16881  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
16882  (vector unsigned long long)__a);
16883 }
16884 
16885 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16886  vector bool long long __b) {
16887  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16888  (vector unsigned long long)__b,
16889  (vector unsigned long long)__a);
16890 }
16891 #endif
16892 
16893 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
16894  vector float __b) {
16895 #ifdef __VSX__
16896  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
16897 #else
16898  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
16899 #endif
16900 }
16901 
16902 #ifdef __VSX__
16903 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
16904  vector double __b) {
16905  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
16906 }
16907 #endif
16908 
16909 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16910 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed __int128 __a,
16911  vector signed __int128 __b) {
16912  return __builtin_altivec_vcmpgtsq_p(__CR6_EQ_REV, __b, __a);
16913 }
16914 
16915 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned __int128 __a,
16916  vector unsigned __int128 __b) {
16917  return __builtin_altivec_vcmpgtuq_p(__CR6_EQ_REV, __b, __a);
16918 }
16919 #endif
16920 
16921 /* vec_any_nan */
16922 
16923 static __inline__ int __ATTRS_o_ai vec_any_nan(vector float __a) {
16924 #ifdef __VSX__
16925  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __a);
16926 #else
16927  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
16928 #endif
16929 }
16930 #ifdef __VSX__
16931 static __inline__ int __ATTRS_o_ai vec_any_nan(vector double __a) {
16932  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __a);
16933 }
16934 #endif
16935 
16936 /* vec_any_ne */
16937 
16938 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
16939  vector signed char __b) {
16940  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16941  (vector char)__b);
16942 }
16943 
16944 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
16945  vector bool char __b) {
16946  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16947  (vector char)__b);
16948 }
16949 
16950 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
16951  vector unsigned char __b) {
16952  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16953  (vector char)__b);
16954 }
16955 
16956 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
16957  vector bool char __b) {
16958  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16959  (vector char)__b);
16960 }
16961 
16962 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
16963  vector signed char __b) {
16964  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16965  (vector char)__b);
16966 }
16967 
16968 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
16969  vector unsigned char __b) {
16970  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16971  (vector char)__b);
16972 }
16973 
16974 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
16975  vector bool char __b) {
16976  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16977  (vector char)__b);
16978 }
16979 
16980 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
16981  vector short __b) {
16982  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
16983 }
16984 
16985 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
16986  vector bool short __b) {
16987  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
16988 }
16989 
16990 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
16991  vector unsigned short __b) {
16992  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16993  (vector short)__b);
16994 }
16995 
16996 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
16997  vector bool short __b) {
16998  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16999  (vector short)__b);
17000 }
17001 
17002 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
17003  vector short __b) {
17004  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17005  (vector short)__b);
17006 }
17007 
17008 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
17009  vector unsigned short __b) {
17010  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17011  (vector short)__b);
17012 }
17013 
17014 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
17015  vector bool short __b) {
17016  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17017  (vector short)__b);
17018 }
17019 
17020 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
17021  vector pixel __b) {
17022  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17023  (vector short)__b);
17024 }
17025 
17026 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
17027  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
17028 }
17029 
17030 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
17031  vector bool int __b) {
17032  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
17033 }
17034 
17035 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
17036  vector unsigned int __b) {
17037  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17038  (vector int)__b);
17039 }
17040 
17041 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
17042  vector bool int __b) {
17043  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17044  (vector int)__b);
17045 }
17046 
17047 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17048  vector int __b) {
17049  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17050  (vector int)__b);
17051 }
17052 
17053 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17054  vector unsigned int __b) {
17055  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17056  (vector int)__b);
17057 }
17058 
17059 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17060  vector bool int __b) {
17061  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17062  (vector int)__b);
17063 }
17064 
17065 #ifdef __VSX__
17066 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
17067  vector signed long long __b) {
17068 #ifdef __POWER8_VECTOR__
17069  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
17070 #else
17071  // Take advantage of the optimized sequence for vec_all_eq when vcmpequd is
17072  // not available.
17073  return !vec_all_eq(__a, __b);
17074 #endif
17075 }
17076 
17077 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
17078  vector unsigned long long __b) {
17079  return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17080 }
17081 
17082 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
17083  vector bool long long __b) {
17084  return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17085 }
17086 
17087 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
17088  vector bool long long __b) {
17089  return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17090 }
17091 
17092 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17093  vector signed long long __b) {
17094  return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17095 }
17096 
17097 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17098  vector unsigned long long __b) {
17099  return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17100 }
17101 
17102 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17103  vector bool long long __b) {
17104  return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17105 }
17106 #endif
17107 
17108 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
17109  vector float __b) {
17110 #ifdef __VSX__
17111  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
17112 #else
17113  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
17114 #endif
17115 }
17116 
17117 #ifdef __VSX__
17118 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
17119  vector double __b) {
17120  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
17121 }
17122 #endif
17123 
17124 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
17125 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed __int128 __a,
17126  vector signed __int128 __b) {
17127  return __builtin_altivec_vcmpequq_p(__CR6_LT_REV, __a, __b);
17128 }
17129 
17130 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned __int128 __a,
17131  vector unsigned __int128 __b) {
17132  return __builtin_altivec_vcmpequq_p(__CR6_LT_REV, __a, __b);
17133 }
17134 
17135 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool __int128 __a,
17136  vector bool __int128 __b) {
17137  return __builtin_altivec_vcmpequq_p(__CR6_LT_REV, __a, __b);
17138 }
17139 #endif
17140 
17141 /* vec_any_nge */
17142 
17143 static __inline__ int __ATTRS_o_ai vec_any_nge(vector float __a,
17144  vector float __b) {
17145 #ifdef __VSX__
17146  return __builtin_vsx_xvcmpgesp_p(__CR6_LT_REV, __a, __b);
17147 #else
17148  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
17149 #endif
17150 }
17151 
17152 #ifdef __VSX__
17153 static __inline__ int __ATTRS_o_ai vec_any_nge(vector double __a,
17154  vector double __b) {
17155  return __builtin_vsx_xvcmpgedp_p(__CR6_LT_REV, __a, __b);
17156 }
17157 #endif
17158 
17159 /* vec_any_ngt */
17160 
17161 static __inline__ int __ATTRS_o_ai vec_any_ngt(vector float __a,
17162  vector float __b) {
17163 #ifdef __VSX__
17164  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT_REV, __a, __b);
17165 #else
17166  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
17167 #endif
17168 }
17169 
17170 #ifdef __VSX__
17171 static __inline__ int __ATTRS_o_ai vec_any_ngt(vector double __a,
17172  vector double __b) {
17173  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT_REV, __a, __b);
17174 }
17175 #endif
17176 
17177 /* vec_any_nle */
17178 
17179 static __inline__ int __ATTRS_o_ai vec_any_nle(vector float __a,
17180  vector float __b) {
17181 #ifdef __VSX__
17182  return __builtin_vsx_xvcmpgesp_p(__CR6_LT_REV, __b, __a);
17183 #else
17184  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
17185 #endif
17186 }
17187 
17188 #ifdef __VSX__
17189 static __inline__ int __ATTRS_o_ai vec_any_nle(vector double __a,
17190  vector double __b) {
17191  return __builtin_vsx_xvcmpgedp_p(__CR6_LT_REV, __b, __a);
17192 }
17193 #endif
17194 
17195 /* vec_any_nlt */
17196 
17197 static __inline__ int __ATTRS_o_ai vec_any_nlt(vector float __a,
17198  vector float __b) {
17199 #ifdef __VSX__
17200  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT_REV, __b, __a);
17201 #else
17202  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
17203 #endif
17204 }
17205 
17206 #ifdef __VSX__
17207 static __inline__ int __ATTRS_o_ai vec_any_nlt(vector double __a,
17208  vector double __b) {
17209  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT_REV, __b, __a);
17210 }
17211 #endif
17212 
17213 /* vec_any_numeric */
17214 
17215 static __inline__ int __ATTRS_o_ai vec_any_numeric(vector float __a) {
17216 #ifdef __VSX__
17217  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __a);
17218 #else
17219  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
17220 #endif
17221 }
17222 
17223 #ifdef __VSX__
17224 static __inline__ int __ATTRS_o_ai vec_any_numeric(vector double __a) {
17225  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __a);
17226 }
17227 #endif
17228 
17229 /* vec_any_out */
17230 
17231 static __inline__ int __attribute__((__always_inline__))
17232 vec_any_out(vector float __a, vector float __b) {
17233  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
17234 }
17235 
17236 /* Power 8 Crypto functions
17237 Note: We diverge from the current GCC implementation with regard
17238 to cryptography and related functions as follows:
17239 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
17240 - The remaining ones are only available on Power8 and up so
17241  require -mpower8-vector
17242 The justification for this is that export requirements require that
17243 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
17244 support). As a result, we need to be able to turn off support for those.
17245 The remaining ones (currently controlled by -mcrypto for GCC) still
17246 need to be provided on compliant hardware even if Vector.Crypto is not
17247 provided.
17248 */
17249 #ifdef __CRYPTO__
17250 #define vec_sbox_be __builtin_altivec_crypto_vsbox
17251 #define vec_cipher_be __builtin_altivec_crypto_vcipher
17252 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
17253 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
17254 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
17255 
17256 #ifdef __VSX__
17257 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17258 __builtin_crypto_vsbox(vector unsigned long long __a) {
17259  return __builtin_altivec_crypto_vsbox(__a);
17260 }
17261 
17262 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17263 __builtin_crypto_vcipher(vector unsigned long long __a,
17264  vector unsigned long long __b) {
17265  return __builtin_altivec_crypto_vcipher(__a, __b);
17266 }
17267 
17268 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17269 __builtin_crypto_vcipherlast(vector unsigned long long __a,
17270  vector unsigned long long __b) {
17271  return __builtin_altivec_crypto_vcipherlast(__a, __b);
17272 }
17273 
17274 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17275 __builtin_crypto_vncipher(vector unsigned long long __a,
17276  vector unsigned long long __b) {
17277  return __builtin_altivec_crypto_vncipher(__a, __b);
17278 }
17279 
17280 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17281 __builtin_crypto_vncipherlast(vector unsigned long long __a,
17282  vector unsigned long long __b) {
17283  return __builtin_altivec_crypto_vncipherlast(__a, __b);
17284 }
17285 #endif /* __VSX__ */
17286 
17287 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
17288 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
17289 
17290 #define vec_shasigma_be(X, Y, Z) \
17291  _Generic((X), vector unsigned int \
17292  : __builtin_crypto_vshasigmaw, vector unsigned long long \
17293  : __builtin_crypto_vshasigmad)((X), (Y), (Z))
17294 #endif
17295 
17296 #ifdef __POWER8_VECTOR__
17297 static __inline__ vector bool char __ATTRS_o_ai
17298 vec_permxor(vector bool char __a, vector bool char __b,
17299  vector bool char __c) {
17300  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17301 }
17302 
17303 static __inline__ vector signed char __ATTRS_o_ai
17304 vec_permxor(vector signed char __a, vector signed char __b,
17305  vector signed char __c) {
17306  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17307 }
17308 
17309 static __inline__ vector unsigned char __ATTRS_o_ai
17310 vec_permxor(vector unsigned char __a, vector unsigned char __b,
17311  vector unsigned char __c) {
17312  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17313 }
17314 
17315 static __inline__ vector unsigned char __ATTRS_o_ai
17316 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
17317  vector unsigned char __c) {
17318  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17319 }
17320 
17321 static __inline__ vector unsigned short __ATTRS_o_ai
17322 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
17323  vector unsigned short __c) {
17324  return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
17325  (vector unsigned char)__a, (vector unsigned char)__b,
17326  (vector unsigned char)__c);
17327 }
17328 
17329 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
17330  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
17331  return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
17332  (vector unsigned char)__a, (vector unsigned char)__b,
17333  (vector unsigned char)__c);
17334 }
17335 
17336 static __inline__ vector unsigned long long __ATTRS_o_ai
17337 __builtin_crypto_vpermxor(vector unsigned long long __a,
17338  vector unsigned long long __b,
17339  vector unsigned long long __c) {
17340  return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
17341  (vector unsigned char)__a, (vector unsigned char)__b,
17342  (vector unsigned char)__c);
17343 }
17344 
17345 static __inline__ vector unsigned char __ATTRS_o_ai
17346 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
17347  return __builtin_altivec_crypto_vpmsumb(__a, __b);
17348 }
17349 
17350 static __inline__ vector unsigned short __ATTRS_o_ai
17351 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
17352  return __builtin_altivec_crypto_vpmsumh(__a, __b);
17353 }
17354 
17355 static __inline__ vector unsigned int __ATTRS_o_ai
17356 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
17357  return __builtin_altivec_crypto_vpmsumw(__a, __b);
17358 }
17359 
17360 static __inline__ vector unsigned long long __ATTRS_o_ai
17361 __builtin_crypto_vpmsumb(vector unsigned long long __a,
17362  vector unsigned long long __b) {
17363  return __builtin_altivec_crypto_vpmsumd(__a, __b);
17364 }
17365 
17366 static __inline__ vector signed char __ATTRS_o_ai
17367 vec_vgbbd(vector signed char __a) {
17368  return __builtin_altivec_vgbbd((vector unsigned char)__a);
17369 }
17370 
17371 #define vec_pmsum_be __builtin_crypto_vpmsumb
17372 #define vec_gb __builtin_altivec_vgbbd
17373 
17374 static __inline__ vector unsigned char __ATTRS_o_ai
17375 vec_vgbbd(vector unsigned char __a) {
17376  return __builtin_altivec_vgbbd(__a);
17377 }
17378 
17379 static __inline__ vector signed long long __ATTRS_o_ai
17380 vec_gbb(vector signed long long __a) {
17381  return __builtin_altivec_vgbbd((vector unsigned char)__a);
17382 }
17383 
17384 static __inline__ vector unsigned long long __ATTRS_o_ai
17385 vec_gbb(vector unsigned long long __a) {
17386  return __builtin_altivec_vgbbd((vector unsigned char)__a);
17387 }
17388 
17389 static __inline__ vector long long __ATTRS_o_ai
17390 vec_vbpermq(vector signed char __a, vector signed char __b) {
17391  return __builtin_altivec_vbpermq((vector unsigned char)__a,
17392  (vector unsigned char)__b);
17393 }
17394 
17395 static __inline__ vector long long __ATTRS_o_ai
17396 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
17397  return __builtin_altivec_vbpermq(__a, __b);
17398 }
17399 
17400 #if defined(__powerpc64__) && defined(__SIZEOF_INT128__)
17401 static __inline__ vector unsigned long long __ATTRS_o_ai
17402 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
17403  return __builtin_altivec_vbpermq((vector unsigned char)__a,
17404  (vector unsigned char)__b);
17405 }
17406 #endif
17407 static __inline__ vector unsigned char __ATTRS_o_ai
17408 vec_bperm(vector unsigned char __a, vector unsigned char __b) {
17409  return __builtin_altivec_vbpermq(__a, __b);
17410 }
17411 #endif // __POWER8_VECTOR__
17412 #ifdef __POWER9_VECTOR__
17413 static __inline__ vector unsigned long long __ATTRS_o_ai
17414 vec_bperm(vector unsigned long long __a, vector unsigned char __b) {
17415  return __builtin_altivec_vbpermd(__a, __b);
17416 }
17417 #endif
17418 
17419 
17420 /* vec_reve */
17421 
17422 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
17423  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17424  5, 4, 3, 2, 1, 0);
17425 }
17426 
17427 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
17428  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17429  5, 4, 3, 2, 1, 0);
17430 }
17431 
17432 static inline __ATTRS_o_ai vector unsigned char
17433 vec_reve(vector unsigned char __a) {
17434  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17435  5, 4, 3, 2, 1, 0);
17436 }
17437 
17438 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
17439  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17440 }
17441 
17442 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
17443  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17444 }
17445 
17446 static inline __ATTRS_o_ai vector unsigned int
17447 vec_reve(vector unsigned int __a) {
17448  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17449 }
17450 
17451 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
17452  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17453 }
17454 
17455 static inline __ATTRS_o_ai vector signed short
17456 vec_reve(vector signed short __a) {
17457  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17458 }
17459 
17460 static inline __ATTRS_o_ai vector unsigned short
17461 vec_reve(vector unsigned short __a) {
17462  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17463 }
17464 
17465 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
17466  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17467 }
17468 
17469 #ifdef __VSX__
17470 static inline __ATTRS_o_ai vector bool long long
17471 vec_reve(vector bool long long __a) {
17472  return __builtin_shufflevector(__a, __a, 1, 0);
17473 }
17474 
17475 static inline __ATTRS_o_ai vector signed long long
17476 vec_reve(vector signed long long __a) {
17477  return __builtin_shufflevector(__a, __a, 1, 0);
17478 }
17479 
17480 static inline __ATTRS_o_ai vector unsigned long long
17481 vec_reve(vector unsigned long long __a) {
17482  return __builtin_shufflevector(__a, __a, 1, 0);
17483 }
17484 
17485 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
17486  return __builtin_shufflevector(__a, __a, 1, 0);
17487 }
17488 #endif
17489 
17490 /* vec_revb */
17491 static __inline__ vector bool char __ATTRS_o_ai
17492 vec_revb(vector bool char __a) {
17493  return __a;
17494 }
17495 
17496 static __inline__ vector signed char __ATTRS_o_ai
17497 vec_revb(vector signed char __a) {
17498  return __a;
17499 }
17500 
17501 static __inline__ vector unsigned char __ATTRS_o_ai
17502 vec_revb(vector unsigned char __a) {
17503  return __a;
17504 }
17505 
17506 static __inline__ vector bool short __ATTRS_o_ai
17507 vec_revb(vector bool short __a) {
17508  vector unsigned char __indices =
17509  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17510  return vec_perm(__a, __a, __indices);
17511 }
17512 
17513 static __inline__ vector signed short __ATTRS_o_ai
17514 vec_revb(vector signed short __a) {
17515  vector unsigned char __indices =
17516  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17517  return vec_perm(__a, __a, __indices);
17518 }
17519 
17520 static __inline__ vector unsigned short __ATTRS_o_ai
17521 vec_revb(vector unsigned short __a) {
17522  vector unsigned char __indices =
17523  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17524  return vec_perm(__a, __a, __indices);
17525 }
17526 
17527 static __inline__ vector bool int __ATTRS_o_ai
17528 vec_revb(vector bool int __a) {
17529  vector unsigned char __indices =
17530  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17531  return vec_perm(__a, __a, __indices);
17532 }
17533 
17534 static __inline__ vector signed int __ATTRS_o_ai
17535 vec_revb(vector signed int __a) {
17536  vector unsigned char __indices =
17537  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17538  return vec_perm(__a, __a, __indices);
17539 }
17540 
17541 static __inline__ vector unsigned int __ATTRS_o_ai
17542 vec_revb(vector unsigned int __a) {
17543  vector unsigned char __indices =
17544  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17545  return vec_perm(__a, __a, __indices);
17546 }
17547 
17548 static __inline__ vector float __ATTRS_o_ai
17549 vec_revb(vector float __a) {
17550  vector unsigned char __indices =
17551  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17552  return vec_perm(__a, __a, __indices);
17553 }
17554 
17555 #ifdef __VSX__
17556 static __inline__ vector bool long long __ATTRS_o_ai
17557 vec_revb(vector bool long long __a) {
17558  vector unsigned char __indices =
17559  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17560  return vec_perm(__a, __a, __indices);
17561 }
17562 
17563 static __inline__ vector signed long long __ATTRS_o_ai
17564 vec_revb(vector signed long long __a) {
17565  vector unsigned char __indices =
17566  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17567  return vec_perm(__a, __a, __indices);
17568 }
17569 
17570 static __inline__ vector unsigned long long __ATTRS_o_ai
17571 vec_revb(vector unsigned long long __a) {
17572  vector unsigned char __indices =
17573  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17574  return vec_perm(__a, __a, __indices);
17575 }
17576 
17577 static __inline__ vector double __ATTRS_o_ai
17578 vec_revb(vector double __a) {
17579  vector unsigned char __indices =
17580  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17581  return vec_perm(__a, __a, __indices);
17582 }
17583 #endif /* End __VSX__ */
17584 
17585 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
17586  defined(__SIZEOF_INT128__)
17587 static __inline__ vector signed __int128 __ATTRS_o_ai
17588 vec_revb(vector signed __int128 __a) {
17589  vector unsigned char __indices =
17590  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
17591  return (vector signed __int128)vec_perm((vector signed int)__a,
17592  (vector signed int)__a,
17593  __indices);
17594 }
17595 
17596 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17597 vec_revb(vector unsigned __int128 __a) {
17598  vector unsigned char __indices =
17599  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
17600  return (vector unsigned __int128)vec_perm((vector signed int)__a,
17601  (vector signed int)__a,
17602  __indices);
17603 }
17604 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
17605 
17606 /* vec_xl */
17607 
17608 #define vec_xld2 vec_xl
17609 #define vec_xlw4 vec_xl
17610 typedef vector signed char unaligned_vec_schar __attribute__((aligned(1)));
17611 typedef vector unsigned char unaligned_vec_uchar __attribute__((aligned(1)));
17612 typedef vector signed short unaligned_vec_sshort __attribute__((aligned(1)));
17613 typedef vector unsigned short unaligned_vec_ushort __attribute__((aligned(1)));
17614 typedef vector signed int unaligned_vec_sint __attribute__((aligned(1)));
17615 typedef vector unsigned int unaligned_vec_uint __attribute__((aligned(1)));
17616 typedef vector float unaligned_vec_float __attribute__((aligned(1)));
17617 
17618 static inline __ATTRS_o_ai vector signed char vec_xl(ptrdiff_t __offset,
17619  const signed char *__ptr) {
17620  return *(unaligned_vec_schar *)(__ptr + __offset);
17621 }
17622 
17623 static inline __ATTRS_o_ai vector unsigned char
17624 vec_xl(ptrdiff_t __offset, const unsigned char *__ptr) {
17625  return *(unaligned_vec_uchar*)(__ptr + __offset);
17626 }
17627 
17628 static inline __ATTRS_o_ai vector signed short
17629 vec_xl(ptrdiff_t __offset, const signed short *__ptr) {
17630  signed char *__addr = (signed char *)__ptr + __offset;
17631  return *(unaligned_vec_sshort *)__addr;
17632 }
17633 
17634 static inline __ATTRS_o_ai vector unsigned short
17635 vec_xl(ptrdiff_t __offset, const unsigned short *__ptr) {
17636  signed char *__addr = (signed char *)__ptr + __offset;
17637  return *(unaligned_vec_ushort *)__addr;
17638 }
17639 
17640 static inline __ATTRS_o_ai vector signed int vec_xl(ptrdiff_t __offset,
17641  const signed int *__ptr) {
17642  signed char *__addr = (signed char *)__ptr + __offset;
17643  return *(unaligned_vec_sint *)__addr;
17644 }
17645 
17646 static inline __ATTRS_o_ai vector unsigned int
17647 vec_xl(ptrdiff_t __offset, const unsigned int *__ptr) {
17648  signed char *__addr = (signed char *)__ptr + __offset;
17649  return *(unaligned_vec_uint *)__addr;
17650 }
17651 
17652 static inline __ATTRS_o_ai vector float vec_xl(ptrdiff_t __offset,
17653  const float *__ptr) {
17654  signed char *__addr = (signed char *)__ptr + __offset;
17655  return *(unaligned_vec_float *)__addr;
17656 }
17657 
17658 #ifdef __VSX__
17659 typedef vector signed long long unaligned_vec_sll __attribute__((aligned(1)));
17660 typedef vector unsigned long long unaligned_vec_ull __attribute__((aligned(1)));
17661 typedef vector double unaligned_vec_double __attribute__((aligned(1)));
17662 
17663 static inline __ATTRS_o_ai vector signed long long
17664 vec_xl(ptrdiff_t __offset, const signed long long *__ptr) {
17665  signed char *__addr = (signed char *)__ptr + __offset;
17666  return *(unaligned_vec_sll *)__addr;
17667 }
17668 
17669 static inline __ATTRS_o_ai vector unsigned long long
17670 vec_xl(ptrdiff_t __offset, const unsigned long long *__ptr) {
17671  signed char *__addr = (signed char *)__ptr + __offset;
17672  return *(unaligned_vec_ull *)__addr;
17673 }
17674 
17675 static inline __ATTRS_o_ai vector double vec_xl(ptrdiff_t __offset,
17676  const double *__ptr) {
17677  signed char *__addr = (signed char *)__ptr + __offset;
17678  return *(unaligned_vec_double *)__addr;
17679 }
17680 #endif
17681 
17682 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
17683  defined(__SIZEOF_INT128__)
17684 typedef vector signed __int128 unaligned_vec_si128 __attribute__((aligned(1)));
17685 typedef vector unsigned __int128 unaligned_vec_ui128
17686  __attribute__((aligned(1)));
17687 static inline __ATTRS_o_ai vector signed __int128
17688 vec_xl(ptrdiff_t __offset, const signed __int128 *__ptr) {
17689  signed char *__addr = (signed char *)__ptr + __offset;
17690  return *(unaligned_vec_si128 *)__addr;
17691 }
17692 
17693 static inline __ATTRS_o_ai vector unsigned __int128
17694 vec_xl(ptrdiff_t __offset, const unsigned __int128 *__ptr) {
17695  signed char *__addr = (signed char *)__ptr + __offset;
17696  return *(unaligned_vec_ui128 *)__addr;
17697 }
17698 #endif
17699 
17700 /* vec_xl_be */
17701 
17702 #ifdef __LITTLE_ENDIAN__
17703 static __inline__ vector signed char __ATTRS_o_ai
17704 vec_xl_be(ptrdiff_t __offset, const signed char *__ptr) {
17705  vector signed char __vec = (vector signed char)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17706  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17707  13, 12, 11, 10, 9, 8);
17708 }
17709 
17710 static __inline__ vector unsigned char __ATTRS_o_ai
17711 vec_xl_be(ptrdiff_t __offset, const unsigned char *__ptr) {
17712  vector unsigned char __vec = (vector unsigned char)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17713  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17714  13, 12, 11, 10, 9, 8);
17715 }
17716 
17717 static __inline__ vector signed short __ATTRS_o_ai
17718 vec_xl_be(ptrdiff_t __offset, const signed short *__ptr) {
17719  vector signed short __vec = (vector signed short)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17720  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17721 }
17722 
17723 static __inline__ vector unsigned short __ATTRS_o_ai
17724 vec_xl_be(ptrdiff_t __offset, const unsigned short *__ptr) {
17725  vector unsigned short __vec = (vector unsigned short)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17726  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17727 }
17728 
17729 static __inline__ vector signed int __ATTRS_o_ai
17730 vec_xl_be(signed long long __offset, const signed int *__ptr) {
17731  return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17732 }
17733 
17734 static __inline__ vector unsigned int __ATTRS_o_ai
17735 vec_xl_be(signed long long __offset, const unsigned int *__ptr) {
17736  return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17737 }
17738 
17739 static __inline__ vector float __ATTRS_o_ai
17740 vec_xl_be(signed long long __offset, const float *__ptr) {
17741  return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17742 }
17743 
17744 #ifdef __VSX__
17745 static __inline__ vector signed long long __ATTRS_o_ai
17746 vec_xl_be(signed long long __offset, const signed long long *__ptr) {
17747  return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17748 }
17749 
17750 static __inline__ vector unsigned long long __ATTRS_o_ai
17751 vec_xl_be(signed long long __offset, const unsigned long long *__ptr) {
17752  return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17753 }
17754 
17755 static __inline__ vector double __ATTRS_o_ai
17756 vec_xl_be(signed long long __offset, const double *__ptr) {
17757  return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17758 }
17759 #endif
17760 
17761 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
17762  defined(__SIZEOF_INT128__)
17763 static __inline__ vector signed __int128 __ATTRS_o_ai
17764 vec_xl_be(signed long long __offset, const signed __int128 *__ptr) {
17765  return vec_xl(__offset, __ptr);
17766 }
17767 
17768 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17769 vec_xl_be(signed long long __offset, const unsigned __int128 *__ptr) {
17770  return vec_xl(__offset, __ptr);
17771 }
17772 #endif
17773 #else
17774  #define vec_xl_be vec_xl
17775 #endif
17776 
17777 #if defined(__POWER10_VECTOR__) && defined(__VSX__) && \
17778  defined(__SIZEOF_INT128__)
17779 
17780 /* vect_xl_sext */
17781 
17782 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17783 vec_xl_sext(ptrdiff_t __offset, const signed char *__pointer) {
17784  return (vector unsigned __int128)*(__pointer + __offset);
17785 }
17786 
17787 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17788 vec_xl_sext(ptrdiff_t __offset, const signed short *__pointer) {
17789  return (vector unsigned __int128)*(__pointer + __offset);
17790 }
17791 
17792 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17793 vec_xl_sext(ptrdiff_t __offset, const signed int *__pointer) {
17794  return (vector unsigned __int128)*(__pointer + __offset);
17795 }
17796 
17797 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17798 vec_xl_sext(ptrdiff_t __offset, const signed long long *__pointer) {
17799  return (vector unsigned __int128)*(__pointer + __offset);
17800 }
17801 
17802 /* vec_xl_zext */
17803 
17804 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17805 vec_xl_zext(ptrdiff_t __offset, const unsigned char *__pointer) {
17806  return (vector unsigned __int128)*(__pointer + __offset);
17807 }
17808 
17809 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17810 vec_xl_zext(ptrdiff_t __offset, const unsigned short *__pointer) {
17811  return (vector unsigned __int128)*(__pointer + __offset);
17812 }
17813 
17814 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17815 vec_xl_zext(ptrdiff_t __offset, const unsigned int *__pointer) {
17816  return (vector unsigned __int128)*(__pointer + __offset);
17817 }
17818 
17819 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17820 vec_xl_zext(ptrdiff_t __offset, const unsigned long long *__pointer) {
17821  return (vector unsigned __int128)*(__pointer + __offset);
17822 }
17823 
17824 #endif
17825 
17826 /* vec_xlds */
17827 #ifdef __VSX__
17828 static __inline__ vector signed long long __ATTRS_o_ai
17829 vec_xlds(ptrdiff_t __offset, const signed long long *__ptr) {
17830  signed long long *__addr = (signed long long*)((signed char *)__ptr + __offset);
17831  return (vector signed long long) *__addr;
17832 }
17833 
17834 static __inline__ vector unsigned long long __ATTRS_o_ai
17835 vec_xlds(ptrdiff_t __offset, const unsigned long long *__ptr) {
17836  unsigned long long *__addr = (unsigned long long *)((signed char *)__ptr + __offset);
17837  return (unaligned_vec_ull) *__addr;
17838 }
17839 
17840 static __inline__ vector double __ATTRS_o_ai vec_xlds(ptrdiff_t __offset,
17841  const double *__ptr) {
17842  double *__addr = (double*)((signed char *)__ptr + __offset);
17843  return (unaligned_vec_double) *__addr;
17844 }
17845 
17846 /* vec_load_splats */
17847 static __inline__ vector signed int __ATTRS_o_ai
17848 vec_load_splats(signed long long __offset, const signed int *__ptr) {
17849  signed int *__addr = (signed int*)((signed char *)__ptr + __offset);
17850  return (vector signed int)*__addr;
17851 }
17852 
17853 static __inline__ vector signed int __ATTRS_o_ai
17854 vec_load_splats(unsigned long long __offset, const signed int *__ptr) {
17855  signed int *__addr = (signed int*)((signed char *)__ptr + __offset);
17856  return (vector signed int)*__addr;
17857 }
17858 
17859 static __inline__ vector unsigned int __ATTRS_o_ai
17860 vec_load_splats(signed long long __offset, const unsigned int *__ptr) {
17861  unsigned int *__addr = (unsigned int*)((signed char *)__ptr + __offset);
17862  return (vector unsigned int)*__addr;
17863 }
17864 
17865 static __inline__ vector unsigned int __ATTRS_o_ai
17866 vec_load_splats(unsigned long long __offset, const unsigned int *__ptr) {
17867  unsigned int *__addr = (unsigned int*)((signed char *)__ptr + __offset);
17868  return (vector unsigned int)*__addr;
17869 }
17870 
17871 static __inline__ vector float __ATTRS_o_ai
17872 vec_load_splats(signed long long __offset, const float *__ptr) {
17873  float *__addr = (float*)((signed char *)__ptr + __offset);
17874  return (vector float)*__addr;
17875 }
17876 
17877 static __inline__ vector float __ATTRS_o_ai
17878 vec_load_splats(unsigned long long __offset, const float *__ptr) {
17879  float *__addr = (float*)((signed char *)__ptr + __offset);
17880  return (vector float)*__addr;
17881 }
17882 #endif
17883 
17884 /* vec_xst */
17885 
17886 #define vec_xstd2 vec_xst
17887 #define vec_xstw4 vec_xst
17888 static inline __ATTRS_o_ai void
17889 vec_xst(vector signed char __vec, ptrdiff_t __offset, signed char *__ptr) {
17890  *(unaligned_vec_schar *)(__ptr + __offset) = __vec;
17891 }
17892 
17893 static inline __ATTRS_o_ai void
17894 vec_xst(vector unsigned char __vec, ptrdiff_t __offset, unsigned char *__ptr) {
17895  *(unaligned_vec_uchar *)(__ptr + __offset) = __vec;
17896 }
17897 
17898 static inline __ATTRS_o_ai void
17899 vec_xst(vector signed short __vec, ptrdiff_t __offset, signed short *__ptr) {
17900  signed char *__addr = (signed char *)__ptr + __offset;
17901  *(unaligned_vec_sshort *)__addr = __vec;
17902 }
17903 
17904 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
17905  ptrdiff_t __offset,
17906  unsigned short *__ptr) {
17907  signed char *__addr = (signed char *)__ptr + __offset;
17908  *(unaligned_vec_ushort *)__addr = __vec;
17909 }
17910 
17911 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
17912  ptrdiff_t __offset, signed int *__ptr) {
17913  signed char *__addr = (signed char *)__ptr + __offset;
17914  *(unaligned_vec_sint *)__addr = __vec;
17915 }
17916 
17917 static inline __ATTRS_o_ai void
17918 vec_xst(vector unsigned int __vec, ptrdiff_t __offset, unsigned int *__ptr) {
17919  signed char *__addr = (signed char *)__ptr + __offset;
17920  *(unaligned_vec_uint *)__addr = __vec;
17921 }
17922 
17923 static inline __ATTRS_o_ai void vec_xst(vector float __vec, ptrdiff_t __offset,
17924  float *__ptr) {
17925  signed char *__addr = (signed char *)__ptr + __offset;
17926  *(unaligned_vec_float *)__addr = __vec;
17927 }
17928 
17929 #ifdef __VSX__
17930 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
17931  ptrdiff_t __offset,
17932  signed long long *__ptr) {
17933  signed char *__addr = (signed char *)__ptr + __offset;
17934  *(unaligned_vec_sll *)__addr = __vec;
17935 }
17936 
17937 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
17938  ptrdiff_t __offset,
17939  unsigned long long *__ptr) {
17940  signed char *__addr = (signed char *)__ptr + __offset;
17941  *(unaligned_vec_ull *)__addr = __vec;
17942 }
17943 
17944 static inline __ATTRS_o_ai void vec_xst(vector double __vec, ptrdiff_t __offset,
17945  double *__ptr) {
17946  signed char *__addr = (signed char *)__ptr + __offset;
17947  *(unaligned_vec_double *)__addr = __vec;
17948 }
17949 #endif
17950 
17951 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
17952  defined(__SIZEOF_INT128__)
17953 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
17954  ptrdiff_t __offset,
17955  signed __int128 *__ptr) {
17956  signed char *__addr = (signed char *)__ptr + __offset;
17957  *(unaligned_vec_si128 *)__addr = __vec;
17958 }
17959 
17960 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
17961  ptrdiff_t __offset,
17962  unsigned __int128 *__ptr) {
17963  signed char *__addr = (signed char *)__ptr + __offset;
17964  *(unaligned_vec_ui128 *)__addr = __vec;
17965 }
17966 #endif
17967 
17968 /* vec_xst_trunc */
17969 
17970 #if defined(__POWER10_VECTOR__) && defined(__VSX__) && \
17971  defined(__SIZEOF_INT128__)
17972 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17973  ptrdiff_t __offset,
17974  signed char *__ptr) {
17975  *(__ptr + __offset) = (signed char)__vec[0];
17976 }
17977 
17978 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
17979  ptrdiff_t __offset,
17980  unsigned char *__ptr) {
17981  *(__ptr + __offset) = (unsigned char)__vec[0];
17982 }
17983 
17984 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17985  ptrdiff_t __offset,
17986  signed short *__ptr) {
17987  *(__ptr + __offset) = (signed short)__vec[0];
17988 }
17989 
17990 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
17991  ptrdiff_t __offset,
17992  unsigned short *__ptr) {
17993  *(__ptr + __offset) = (unsigned short)__vec[0];
17994 }
17995 
17996 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17997  ptrdiff_t __offset,
17998  signed int *__ptr) {
17999  *(__ptr + __offset) = (signed int)__vec[0];
18000 }
18001 
18002 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
18003  ptrdiff_t __offset,
18004  unsigned int *__ptr) {
18005  *(__ptr + __offset) = (unsigned int)__vec[0];
18006 }
18007 
18008 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
18009  ptrdiff_t __offset,
18010  signed long long *__ptr) {
18011  *(__ptr + __offset) = (signed long long)__vec[0];
18012 }
18013 
18014 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
18015  ptrdiff_t __offset,
18016  unsigned long long *__ptr) {
18017  *(__ptr + __offset) = (unsigned long long)__vec[0];
18018 }
18019 #endif
18020 
18021 /* vec_xst_be */
18022 
18023 #ifdef __LITTLE_ENDIAN__
18024 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
18025  signed long long __offset,
18026  signed char *__ptr) {
18027  vector signed char __tmp =
18028  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
18029  13, 12, 11, 10, 9, 8);
18030  typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18031  __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18032 }
18033 
18034 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
18035  signed long long __offset,
18036  unsigned char *__ptr) {
18037  vector unsigned char __tmp =
18038  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
18039  13, 12, 11, 10, 9, 8);
18040  typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18041  __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18042 }
18043 
18044 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
18045  signed long long __offset,
18046  signed short *__ptr) {
18047  vector signed short __tmp =
18048  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
18049  typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18050  __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18051 }
18052 
18053 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
18054  signed long long __offset,
18055  unsigned short *__ptr) {
18056  vector unsigned short __tmp =
18057  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
18058  typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18059  __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18060 }
18061 
18062 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
18063  signed long long __offset,
18064  signed int *__ptr) {
18065  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
18066 }
18067 
18068 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
18069  signed long long __offset,
18070  unsigned int *__ptr) {
18071  __builtin_vsx_stxvw4x_be((vector int)__vec, __offset, __ptr);
18072 }
18073 
18074 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
18075  signed long long __offset,
18076  float *__ptr) {
18077  __builtin_vsx_stxvw4x_be((vector int)__vec, __offset, __ptr);
18078 }
18079 
18080 #ifdef __VSX__
18081 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
18082  signed long long __offset,
18083  signed long long *__ptr) {
18084  __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18085 }
18086 
18087 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
18088  signed long long __offset,
18089  unsigned long long *__ptr) {
18090  __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18091 }
18092 
18093 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
18094  signed long long __offset,
18095  double *__ptr) {
18096  __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18097 }
18098 #endif
18099 
18100 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) && \
18101  defined(__SIZEOF_INT128__)
18102 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
18103  signed long long __offset,
18104  signed __int128 *__ptr) {
18105  vec_xst(__vec, __offset, __ptr);
18106 }
18107 
18108 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
18109  signed long long __offset,
18110  unsigned __int128 *__ptr) {
18111  vec_xst(__vec, __offset, __ptr);
18112 }
18113 #endif
18114 #else
18115  #define vec_xst_be vec_xst
18116 #endif
18117 
18118 #ifdef __POWER9_VECTOR__
18119 #define vec_test_data_class(__a, __b) \
18120  _Generic( \
18121  (__a), vector float \
18122  : (vector bool int)__builtin_vsx_xvtstdcsp((vector float)(__a), (__b)), \
18123  vector double \
18124  : (vector bool long long)__builtin_vsx_xvtstdcdp((vector double)(__a), \
18125  (__b)))
18126 
18127 #endif /* #ifdef __POWER9_VECTOR__ */
18128 
18129 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
18130  return -__a;
18131 }
18132 
18133 #ifdef __VSX__
18134 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
18135  return -__a;
18136 }
18137 
18138 #endif
18139 
18140 #ifdef __VSX__
18141 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
18142  return -__a;
18143 }
18144 #endif
18145 
18146 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
18147  return -__a;
18148 }
18149 
18150 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
18151  return -__a;
18152 }
18153 
18154 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
18155  return -__a;
18156 }
18157 
18158 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
18159  return - vec_abs(__a);
18160 }
18161 
18162 #ifdef __VSX__
18163 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
18164  return - vec_abs(__a);
18165 }
18166 
18167 #endif
18168 
18169 #ifdef __POWER8_VECTOR__
18170 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
18171  return __builtin_altivec_vminsd(__a, -__a);
18172 }
18173 #endif
18174 
18175 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
18176  return __builtin_altivec_vminsw(__a, -__a);
18177 }
18178 
18179 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
18180  return __builtin_altivec_vminsh(__a, -__a);
18181 }
18182 
18183 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
18184  return __builtin_altivec_vminsb(__a, -__a);
18185 }
18186 
18187 static vector float __ATTRS_o_ai vec_recipdiv(vector float __a,
18188  vector float __b) {
18189  return __builtin_ppc_recipdivf(__a, __b);
18190 }
18191 
18192 #ifdef __VSX__
18193 static vector double __ATTRS_o_ai vec_recipdiv(vector double __a,
18194  vector double __b) {
18195  return __builtin_ppc_recipdivd(__a, __b);
18196 }
18197 #endif
18198 
18199 #ifdef __POWER10_VECTOR__
18200 
18201 /* vec_extractm */
18202 
18203 static __inline__ unsigned int __ATTRS_o_ai
18204 vec_extractm(vector unsigned char __a) {
18205  return __builtin_altivec_vextractbm(__a);
18206 }
18207 
18208 static __inline__ unsigned int __ATTRS_o_ai
18209 vec_extractm(vector unsigned short __a) {
18210  return __builtin_altivec_vextracthm(__a);
18211 }
18212 
18213 static __inline__ unsigned int __ATTRS_o_ai
18214 vec_extractm(vector unsigned int __a) {
18215  return __builtin_altivec_vextractwm(__a);
18216 }
18217 
18218 static __inline__ unsigned int __ATTRS_o_ai
18219 vec_extractm(vector unsigned long long __a) {
18220  return __builtin_altivec_vextractdm(__a);
18221 }
18222 
18223 #ifdef __SIZEOF_INT128__
18224 static __inline__ unsigned int __ATTRS_o_ai
18225 vec_extractm(vector unsigned __int128 __a) {
18226  return __builtin_altivec_vextractqm(__a);
18227 }
18228 #endif
18229 
18230 /* vec_expandm */
18231 
18232 static __inline__ vector unsigned char __ATTRS_o_ai
18233 vec_expandm(vector unsigned char __a) {
18234  return __builtin_altivec_vexpandbm(__a);
18235 }
18236 
18237 static __inline__ vector unsigned short __ATTRS_o_ai
18238 vec_expandm(vector unsigned short __a) {
18239  return __builtin_altivec_vexpandhm(__a);
18240 }
18241 
18242 static __inline__ vector unsigned int __ATTRS_o_ai
18243 vec_expandm(vector unsigned int __a) {
18244  return __builtin_altivec_vexpandwm(__a);
18245 }
18246 
18247 static __inline__ vector unsigned long long __ATTRS_o_ai
18248 vec_expandm(vector unsigned long long __a) {
18249  return __builtin_altivec_vexpanddm(__a);
18250 }
18251 
18252 #ifdef __SIZEOF_INT128__
18253 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18254 vec_expandm(vector unsigned __int128 __a) {
18255  return __builtin_altivec_vexpandqm(__a);
18256 }
18257 #endif
18258 
18259 /* vec_cntm */
18260 
18261 #define vec_cntm(__a, __mp) \
18262  _Generic((__a), vector unsigned char \
18263  : __builtin_altivec_vcntmbb((__a), (unsigned char)(__mp)), \
18264  vector unsigned short \
18265  : __builtin_altivec_vcntmbh((__a), (unsigned char)(__mp)), \
18266  vector unsigned int \
18267  : __builtin_altivec_vcntmbw((__a), (unsigned char)(__mp)), \
18268  vector unsigned long long \
18269  : __builtin_altivec_vcntmbd((__a), (unsigned char)(__mp)))
18270 
18271 /* vec_gen[b|h|w|d|q]m */
18272 
18273 static __inline__ vector unsigned char __ATTRS_o_ai
18274 vec_genbm(unsigned long long __bm) {
18275  return __builtin_altivec_mtvsrbm(__bm);
18276 }
18277 
18278 static __inline__ vector unsigned short __ATTRS_o_ai
18279 vec_genhm(unsigned long long __bm) {
18280  return __builtin_altivec_mtvsrhm(__bm);
18281 }
18282 
18283 static __inline__ vector unsigned int __ATTRS_o_ai
18284 vec_genwm(unsigned long long __bm) {
18285  return __builtin_altivec_mtvsrwm(__bm);
18286 }
18287 
18288 static __inline__ vector unsigned long long __ATTRS_o_ai
18289 vec_gendm(unsigned long long __bm) {
18290  return __builtin_altivec_mtvsrdm(__bm);
18291 }
18292 
18293 #ifdef __SIZEOF_INT128__
18294 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18295 vec_genqm(unsigned long long __bm) {
18296  return __builtin_altivec_mtvsrqm(__bm);
18297 }
18298 #endif
18299 
18300 /* vec_pdep */
18301 
18302 static __inline__ vector unsigned long long __ATTRS_o_ai
18303 vec_pdep(vector unsigned long long __a, vector unsigned long long __b) {
18304  return __builtin_altivec_vpdepd(__a, __b);
18305 }
18306 
18307 /* vec_pext */
18308 
18309 static __inline__ vector unsigned long long __ATTRS_o_ai
18310 vec_pext(vector unsigned long long __a, vector unsigned long long __b) {
18311  return __builtin_altivec_vpextd(__a, __b);
18312 }
18313 
18314 /* vec_cfuge */
18315 
18316 static __inline__ vector unsigned long long __ATTRS_o_ai
18317 vec_cfuge(vector unsigned long long __a, vector unsigned long long __b) {
18318  return __builtin_altivec_vcfuged(__a, __b);
18319 }
18320 
18321 /* vec_gnb */
18322 
18323 #define vec_gnb(__a, __b) __builtin_altivec_vgnb(__a, __b)
18324 
18325 /* vec_ternarylogic */
18326 #ifdef __VSX__
18327 #ifdef __SIZEOF_INT128__
18328 #define vec_ternarylogic(__a, __b, __c, __imm) \
18329  _Generic((__a), vector unsigned char \
18330  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18331  (vector unsigned long long)(__b), \
18332  (vector unsigned long long)(__c), (__imm)), \
18333  vector unsigned short \
18334  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18335  (vector unsigned long long)(__b), \
18336  (vector unsigned long long)(__c), (__imm)), \
18337  vector unsigned int \
18338  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18339  (vector unsigned long long)(__b), \
18340  (vector unsigned long long)(__c), (__imm)), \
18341  vector unsigned long long \
18342  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18343  (vector unsigned long long)(__b), \
18344  (vector unsigned long long)(__c), (__imm)), \
18345  vector unsigned __int128 \
18346  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18347  (vector unsigned long long)(__b), \
18348  (vector unsigned long long)(__c), (__imm)))
18349 #else
18350 #define vec_ternarylogic(__a, __b, __c, __imm) \
18351  _Generic((__a), vector unsigned char \
18352  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18353  (vector unsigned long long)(__b), \
18354  (vector unsigned long long)(__c), (__imm)), \
18355  vector unsigned short \
18356  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18357  (vector unsigned long long)(__b), \
18358  (vector unsigned long long)(__c), (__imm)), \
18359  vector unsigned int \
18360  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18361  (vector unsigned long long)(__b), \
18362  (vector unsigned long long)(__c), (__imm)), \
18363  vector unsigned long long \
18364  : __builtin_vsx_xxeval((vector unsigned long long)(__a), \
18365  (vector unsigned long long)(__b), \
18366  (vector unsigned long long)(__c), (__imm)))
18367 #endif /* __SIZEOF_INT128__ */
18368 #endif /* __VSX__ */
18369 
18370 /* vec_genpcvm */
18371 
18372 #ifdef __VSX__
18373 #define vec_genpcvm(__a, __imm) \
18374  _Generic((__a), vector unsigned char \
18375  : __builtin_vsx_xxgenpcvbm((__a), (int)(__imm)), \
18376  vector unsigned short \
18377  : __builtin_vsx_xxgenpcvhm((__a), (int)(__imm)), \
18378  vector unsigned int \
18379  : __builtin_vsx_xxgenpcvwm((__a), (int)(__imm)), \
18380  vector unsigned long long \
18381  : __builtin_vsx_xxgenpcvdm((__a), (int)(__imm)))
18382 #endif /* __VSX__ */
18383 
18384 /* vec_clr_first */
18385 
18386 static __inline__ vector signed char __ATTRS_o_ai
18387 vec_clr_first(vector signed char __a, unsigned int __n) {
18388 #ifdef __LITTLE_ENDIAN__
18389  return __builtin_altivec_vclrrb(__a, __n);
18390 #else
18391  return __builtin_altivec_vclrlb( __a, __n);
18392 #endif
18393 }
18394 
18395 static __inline__ vector unsigned char __ATTRS_o_ai
18396 vec_clr_first(vector unsigned char __a, unsigned int __n) {
18397 #ifdef __LITTLE_ENDIAN__
18398  return __builtin_altivec_vclrrb((vector signed char)__a, __n);
18399 #else
18400  return __builtin_altivec_vclrlb((vector signed char)__a, __n);
18401 #endif
18402 }
18403 
18404 /* vec_clr_last */
18405 
18406 static __inline__ vector signed char __ATTRS_o_ai
18407 vec_clr_last(vector signed char __a, unsigned int __n) {
18408 #ifdef __LITTLE_ENDIAN__
18409  return __builtin_altivec_vclrlb(__a, __n);
18410 #else
18411  return __builtin_altivec_vclrrb( __a, __n);
18412 #endif
18413 }
18414 
18415 static __inline__ vector unsigned char __ATTRS_o_ai
18416 vec_clr_last(vector unsigned char __a, unsigned int __n) {
18417 #ifdef __LITTLE_ENDIAN__
18418  return __builtin_altivec_vclrlb((vector signed char)__a, __n);
18419 #else
18420  return __builtin_altivec_vclrrb((vector signed char)__a, __n);
18421 #endif
18422 }
18423 
18424 /* vec_cntlzm */
18425 
18426 static __inline__ vector unsigned long long __ATTRS_o_ai
18427 vec_cntlzm(vector unsigned long long __a, vector unsigned long long __b) {
18428  return __builtin_altivec_vclzdm(__a, __b);
18429 }
18430 
18431 /* vec_cnttzm */
18432 
18433 static __inline__ vector unsigned long long __ATTRS_o_ai
18434 vec_cnttzm(vector unsigned long long __a, vector unsigned long long __b) {
18435  return __builtin_altivec_vctzdm(__a, __b);
18436 }
18437 
18438 /* vec_mod */
18439 
18440 static __inline__ vector signed int __ATTRS_o_ai
18441 vec_mod(vector signed int __a, vector signed int __b) {
18442  return __a % __b;
18443 }
18444 
18445 static __inline__ vector unsigned int __ATTRS_o_ai
18446 vec_mod(vector unsigned int __a, vector unsigned int __b) {
18447  return __a % __b;
18448 }
18449 
18450 static __inline__ vector signed long long __ATTRS_o_ai
18451 vec_mod(vector signed long long __a, vector signed long long __b) {
18452  return __a % __b;
18453 }
18454 
18455 static __inline__ vector unsigned long long __ATTRS_o_ai
18456 vec_mod(vector unsigned long long __a, vector unsigned long long __b) {
18457  return __a % __b;
18458 }
18459 
18460 #ifdef __SIZEOF_INT128__
18461 static __inline__ vector signed __int128 __ATTRS_o_ai
18462 vec_mod(vector signed __int128 __a, vector signed __int128 __b) {
18463  return __a % __b;
18464 }
18465 
18466 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18467 vec_mod(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18468  return __a % __b;
18469 }
18470 #endif
18471 
18472 /* vec_sldbi */
18473 
18474 #define vec_sldb(__a, __b, __c) __builtin_altivec_vsldbi(__a, __b, (__c & 0x7))
18475 
18476 /* vec_srdbi */
18477 
18478 #define vec_srdb(__a, __b, __c) __builtin_altivec_vsrdbi(__a, __b, (__c & 0x7))
18479 
18480 /* vec_insertl */
18481 
18482 static __inline__ vector unsigned char __ATTRS_o_ai
18483 vec_insertl(unsigned char __a, vector unsigned char __b, unsigned int __c) {
18484 #ifdef __LITTLE_ENDIAN__
18485  return __builtin_altivec_vinsbrx(__b, __c, __a);
18486 #else
18487  return __builtin_altivec_vinsblx(__b, __c, __a);
18488 #endif
18489 }
18490 
18491 static __inline__ vector unsigned short __ATTRS_o_ai
18492 vec_insertl(unsigned short __a, vector unsigned short __b, unsigned int __c) {
18493 #ifdef __LITTLE_ENDIAN__
18494  return __builtin_altivec_vinshrx(__b, __c, __a);
18495 #else
18496  return __builtin_altivec_vinshlx(__b, __c, __a);
18497 #endif
18498 }
18499 
18500 static __inline__ vector unsigned int __ATTRS_o_ai
18501 vec_insertl(unsigned int __a, vector unsigned int __b, unsigned int __c) {
18502 #ifdef __LITTLE_ENDIAN__
18503  return __builtin_altivec_vinswrx(__b, __c, __a);
18504 #else
18505  return __builtin_altivec_vinswlx(__b, __c, __a);
18506 #endif
18507 }
18508 
18509 static __inline__ vector unsigned long long __ATTRS_o_ai
18510 vec_insertl(unsigned long long __a, vector unsigned long long __b,
18511  unsigned int __c) {
18512 #ifdef __LITTLE_ENDIAN__
18513  return __builtin_altivec_vinsdrx(__b, __c, __a);
18514 #else
18515  return __builtin_altivec_vinsdlx(__b, __c, __a);
18516 #endif
18517 }
18518 
18519 static __inline__ vector unsigned char __ATTRS_o_ai
18520 vec_insertl(vector unsigned char __a, vector unsigned char __b,
18521  unsigned int __c) {
18522 #ifdef __LITTLE_ENDIAN__
18523  return __builtin_altivec_vinsbvrx(__b, __c, __a);
18524 #else
18525  return __builtin_altivec_vinsbvlx(__b, __c, __a);
18526 #endif
18527 }
18528 
18529 static __inline__ vector unsigned short __ATTRS_o_ai
18530 vec_insertl(vector unsigned short __a, vector unsigned short __b,
18531  unsigned int __c) {
18532 #ifdef __LITTLE_ENDIAN__
18533  return __builtin_altivec_vinshvrx(__b, __c, __a);
18534 #else
18535  return __builtin_altivec_vinshvlx(__b, __c, __a);
18536 #endif
18537 }
18538 
18539 static __inline__ vector unsigned int __ATTRS_o_ai
18540 vec_insertl(vector unsigned int __a, vector unsigned int __b,
18541  unsigned int __c) {
18542 #ifdef __LITTLE_ENDIAN__
18543  return __builtin_altivec_vinswvrx(__b, __c, __a);
18544 #else
18545  return __builtin_altivec_vinswvlx(__b, __c, __a);
18546 #endif
18547 }
18548 
18549 /* vec_inserth */
18550 
18551 static __inline__ vector unsigned char __ATTRS_o_ai
18552 vec_inserth(unsigned char __a, vector unsigned char __b, unsigned int __c) {
18553 #ifdef __LITTLE_ENDIAN__
18554  return __builtin_altivec_vinsblx(__b, __c, __a);
18555 #else
18556  return __builtin_altivec_vinsbrx(__b, __c, __a);
18557 #endif
18558 }
18559 
18560 static __inline__ vector unsigned short __ATTRS_o_ai
18561 vec_inserth(unsigned short __a, vector unsigned short __b, unsigned int __c) {
18562 #ifdef __LITTLE_ENDIAN__
18563  return __builtin_altivec_vinshlx(__b, __c, __a);
18564 #else
18565  return __builtin_altivec_vinshrx(__b, __c, __a);
18566 #endif
18567 }
18568 
18569 static __inline__ vector unsigned int __ATTRS_o_ai
18570 vec_inserth(unsigned int __a, vector unsigned int __b, unsigned int __c) {
18571 #ifdef __LITTLE_ENDIAN__
18572  return __builtin_altivec_vinswlx(__b, __c, __a);
18573 #else
18574  return __builtin_altivec_vinswrx(__b, __c, __a);
18575 #endif
18576 }
18577 
18578 static __inline__ vector unsigned long long __ATTRS_o_ai
18579 vec_inserth(unsigned long long __a, vector unsigned long long __b,
18580  unsigned int __c) {
18581 #ifdef __LITTLE_ENDIAN__
18582  return __builtin_altivec_vinsdlx(__b, __c, __a);
18583 #else
18584  return __builtin_altivec_vinsdrx(__b, __c, __a);
18585 #endif
18586 }
18587 
18588 static __inline__ vector unsigned char __ATTRS_o_ai
18589 vec_inserth(vector unsigned char __a, vector unsigned char __b,
18590  unsigned int __c) {
18591 #ifdef __LITTLE_ENDIAN__
18592  return __builtin_altivec_vinsbvlx(__b, __c, __a);
18593 #else
18594  return __builtin_altivec_vinsbvrx(__b, __c, __a);
18595 #endif
18596 }
18597 
18598 static __inline__ vector unsigned short __ATTRS_o_ai
18599 vec_inserth(vector unsigned short __a, vector unsigned short __b,
18600  unsigned int __c) {
18601 #ifdef __LITTLE_ENDIAN__
18602  return __builtin_altivec_vinshvlx(__b, __c, __a);
18603 #else
18604  return __builtin_altivec_vinshvrx(__b, __c, __a);
18605 #endif
18606 }
18607 
18608 static __inline__ vector unsigned int __ATTRS_o_ai
18609 vec_inserth(vector unsigned int __a, vector unsigned int __b,
18610  unsigned int __c) {
18611 #ifdef __LITTLE_ENDIAN__
18612  return __builtin_altivec_vinswvlx(__b, __c, __a);
18613 #else
18614  return __builtin_altivec_vinswvrx(__b, __c, __a);
18615 #endif
18616 }
18617 
18618 /* vec_extractl */
18619 
18620 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18621  vector unsigned char __a, vector unsigned char __b, unsigned int __c) {
18622 #ifdef __LITTLE_ENDIAN__
18623  return __builtin_altivec_vextdubvrx(__a, __b, __c);
18624 #else
18625  vector unsigned long long __ret = __builtin_altivec_vextdubvlx(__a, __b, __c);
18626  return vec_sld(__ret, __ret, 8);
18627 #endif
18628 }
18629 
18630 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18631  vector unsigned short __a, vector unsigned short __b, unsigned int __c) {
18632 #ifdef __LITTLE_ENDIAN__
18633  return __builtin_altivec_vextduhvrx(__a, __b, __c);
18634 #else
18635  vector unsigned long long __ret = __builtin_altivec_vextduhvlx(__a, __b, __c);
18636  return vec_sld(__ret, __ret, 8);
18637 #endif
18638 }
18639 
18640 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18641  vector unsigned int __a, vector unsigned int __b, unsigned int __c) {
18642 #ifdef __LITTLE_ENDIAN__
18643  return __builtin_altivec_vextduwvrx(__a, __b, __c);
18644 #else
18645  vector unsigned long long __ret = __builtin_altivec_vextduwvlx(__a, __b, __c);
18646  return vec_sld(__ret, __ret, 8);
18647 #endif
18648 }
18649 
18650 static __inline__ vector unsigned long long __ATTRS_o_ai
18651 vec_extractl(vector unsigned long long __a, vector unsigned long long __b,
18652  unsigned int __c) {
18653 #ifdef __LITTLE_ENDIAN__
18654  return __builtin_altivec_vextddvrx(__a, __b, __c);
18655 #else
18656  vector unsigned long long __ret = __builtin_altivec_vextddvlx(__a, __b, __c);
18657  return vec_sld(__ret, __ret, 8);
18658 #endif
18659 }
18660 
18661 /* vec_extracth */
18662 
18663 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18664  vector unsigned char __a, vector unsigned char __b, unsigned int __c) {
18665 #ifdef __LITTLE_ENDIAN__
18666  return __builtin_altivec_vextdubvlx(__a, __b, __c);
18667 #else
18668  vector unsigned long long __ret = __builtin_altivec_vextdubvrx(__a, __b, __c);
18669  return vec_sld(__ret, __ret, 8);
18670 #endif
18671 }
18672 
18673 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18674  vector unsigned short __a, vector unsigned short __b, unsigned int __c) {
18675 #ifdef __LITTLE_ENDIAN__
18676  return __builtin_altivec_vextduhvlx(__a, __b, __c);
18677 #else
18678  vector unsigned long long __ret = __builtin_altivec_vextduhvrx(__a, __b, __c);
18679  return vec_sld(__ret, __ret, 8);
18680 #endif
18681 }
18682 
18683 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18684  vector unsigned int __a, vector unsigned int __b, unsigned int __c) {
18685 #ifdef __LITTLE_ENDIAN__
18686  return __builtin_altivec_vextduwvlx(__a, __b, __c);
18687 #else
18688  vector unsigned long long __ret = __builtin_altivec_vextduwvrx(__a, __b, __c);
18689  return vec_sld(__ret, __ret, 8);
18690 #endif
18691 }
18692 
18693 static __inline__ vector unsigned long long __ATTRS_o_ai
18694 vec_extracth(vector unsigned long long __a, vector unsigned long long __b,
18695  unsigned int __c) {
18696 #ifdef __LITTLE_ENDIAN__
18697  return __builtin_altivec_vextddvlx(__a, __b, __c);
18698 #else
18699  vector unsigned long long __ret = __builtin_altivec_vextddvrx(__a, __b, __c);
18700  return vec_sld(__ret, __ret, 8);
18701 #endif
18702 }
18703 
18704 #ifdef __VSX__
18705 
18706 /* vec_permx */
18707 
18708 #define vec_permx(__a, __b, __c, __d) \
18709  __builtin_vsx_xxpermx((__a), (__b), (__c), (__d))
18710 
18711 /* vec_blendv */
18712 
18713 static __inline__ vector signed char __ATTRS_o_ai
18714 vec_blendv(vector signed char __a, vector signed char __b,
18715  vector unsigned char __c) {
18716  return __builtin_vsx_xxblendvb(__a, __b, __c);
18717 }
18718 
18719 static __inline__ vector unsigned char __ATTRS_o_ai
18720 vec_blendv(vector unsigned char __a, vector unsigned char __b,
18721  vector unsigned char __c) {
18722  return __builtin_vsx_xxblendvb(__a, __b, __c);
18723 }
18724 
18725 static __inline__ vector signed short __ATTRS_o_ai
18726 vec_blendv(vector signed short __a, vector signed short __b,
18727  vector unsigned short __c) {
18728  return __builtin_vsx_xxblendvh(__a, __b, __c);
18729 }
18730 
18731 static __inline__ vector unsigned short __ATTRS_o_ai
18732 vec_blendv(vector unsigned short __a, vector unsigned short __b,
18733  vector unsigned short __c) {
18734  return __builtin_vsx_xxblendvh(__a, __b, __c);
18735 }
18736 
18737 static __inline__ vector signed int __ATTRS_o_ai
18738 vec_blendv(vector signed int __a, vector signed int __b,
18739  vector unsigned int __c) {
18740  return __builtin_vsx_xxblendvw(__a, __b, __c);
18741 }
18742 
18743 static __inline__ vector unsigned int __ATTRS_o_ai
18744 vec_blendv(vector unsigned int __a, vector unsigned int __b,
18745  vector unsigned int __c) {
18746  return __builtin_vsx_xxblendvw(__a, __b, __c);
18747 }
18748 
18749 static __inline__ vector signed long long __ATTRS_o_ai
18750 vec_blendv(vector signed long long __a, vector signed long long __b,
18751  vector unsigned long long __c) {
18752  return __builtin_vsx_xxblendvd(__a, __b, __c);
18753 }
18754 
18755 static __inline__ vector unsigned long long __ATTRS_o_ai
18756 vec_blendv(vector unsigned long long __a, vector unsigned long long __b,
18757  vector unsigned long long __c) {
18758  return __builtin_vsx_xxblendvd(__a, __b, __c);
18759 }
18760 
18761 static __inline__ vector float __ATTRS_o_ai
18762 vec_blendv(vector float __a, vector float __b, vector unsigned int __c) {
18763  return __builtin_vsx_xxblendvw(__a, __b, __c);
18764 }
18765 
18766 static __inline__ vector double __ATTRS_o_ai
18767 vec_blendv(vector double __a, vector double __b,
18768  vector unsigned long long __c) {
18769  return __builtin_vsx_xxblendvd(__a, __b, __c);
18770 }
18771 
18772 /* vec_replace_elt */
18773 
18774 #define vec_replace_elt __builtin_altivec_vec_replace_elt
18775 
18776 /* vec_replace_unaligned */
18777 
18778 #define vec_replace_unaligned __builtin_altivec_vec_replace_unaligned
18779 
18780 /* vec_splati */
18781 
18782 #define vec_splati(__a) \
18783  _Generic((__a), signed int \
18784  : ((vector signed int)__a), unsigned int \
18785  : ((vector unsigned int)__a), float \
18786  : ((vector float)__a))
18787 
18788 /* vec_spatid */
18789 
18790 static __inline__ vector double __ATTRS_o_ai vec_splatid(const float __a) {
18791  return ((vector double)((double)__a));
18792 }
18793 
18794 /* vec_splati_ins */
18795 
18796 static __inline__ vector signed int __ATTRS_o_ai vec_splati_ins(
18797  vector signed int __a, const unsigned int __b, const signed int __c) {
18798  const unsigned int __d = __b & 0x01;
18799 #ifdef __LITTLE_ENDIAN__
18800  __a[1 - __d] = __c;
18801  __a[3 - __d] = __c;
18802 #else
18803  __a[__d] = __c;
18804  __a[2 + __d] = __c;
18805 #endif
18806  return __a;
18807 }
18808 
18809 static __inline__ vector unsigned int __ATTRS_o_ai vec_splati_ins(
18810  vector unsigned int __a, const unsigned int __b, const unsigned int __c) {
18811  const unsigned int __d = __b & 0x01;
18812 #ifdef __LITTLE_ENDIAN__
18813  __a[1 - __d] = __c;
18814  __a[3 - __d] = __c;
18815 #else
18816  __a[__d] = __c;
18817  __a[2 + __d] = __c;
18818 #endif
18819  return __a;
18820 }
18821 
18822 static __inline__ vector float __ATTRS_o_ai
18823 vec_splati_ins(vector float __a, const unsigned int __b, const float __c) {
18824  const unsigned int __d = __b & 0x01;
18825 #ifdef __LITTLE_ENDIAN__
18826  __a[1 - __d] = __c;
18827  __a[3 - __d] = __c;
18828 #else
18829  __a[__d] = __c;
18830  __a[2 + __d] = __c;
18831 #endif
18832  return __a;
18833 }
18834 
18835 /* vec_test_lsbb_all_ones */
18836 
18837 static __inline__ int __ATTRS_o_ai
18838 vec_test_lsbb_all_ones(vector unsigned char __a) {
18839  return __builtin_vsx_xvtlsbb(__a, 1);
18840 }
18841 
18842 /* vec_test_lsbb_all_zeros */
18843 
18844 static __inline__ int __ATTRS_o_ai
18845 vec_test_lsbb_all_zeros(vector unsigned char __a) {
18846  return __builtin_vsx_xvtlsbb(__a, 0);
18847 }
18848 #endif /* __VSX__ */
18849 
18850 /* vec_stril */
18851 
18852 static __inline__ vector unsigned char __ATTRS_o_ai
18853 vec_stril(vector unsigned char __a) {
18854 #ifdef __LITTLE_ENDIAN__
18855  return __builtin_altivec_vstribr((vector signed char)__a);
18856 #else
18857  return __builtin_altivec_vstribl((vector signed char)__a);
18858 #endif
18859 }
18860 
18861 static __inline__ vector signed char __ATTRS_o_ai
18862 vec_stril(vector signed char __a) {
18863 #ifdef __LITTLE_ENDIAN__
18864  return __builtin_altivec_vstribr(__a);
18865 #else
18866  return __builtin_altivec_vstribl(__a);
18867 #endif
18868 }
18869 
18870 static __inline__ vector unsigned short __ATTRS_o_ai
18871 vec_stril(vector unsigned short __a) {
18872 #ifdef __LITTLE_ENDIAN__
18873  return __builtin_altivec_vstrihr((vector signed short)__a);
18874 #else
18875  return __builtin_altivec_vstrihl((vector signed short)__a);
18876 #endif
18877 }
18878 
18879 static __inline__ vector signed short __ATTRS_o_ai
18880 vec_stril(vector signed short __a) {
18881 #ifdef __LITTLE_ENDIAN__
18882  return __builtin_altivec_vstrihr(__a);
18883 #else
18884  return __builtin_altivec_vstrihl(__a);
18885 #endif
18886 }
18887 
18888 /* vec_stril_p */
18889 
18890 static __inline__ int __ATTRS_o_ai vec_stril_p(vector unsigned char __a) {
18891 #ifdef __LITTLE_ENDIAN__
18892  return __builtin_altivec_vstribr_p(__CR6_EQ, (vector signed char)__a);
18893 #else
18894  return __builtin_altivec_vstribl_p(__CR6_EQ, (vector signed char)__a);
18895 #endif
18896 }
18897 
18898 static __inline__ int __ATTRS_o_ai vec_stril_p(vector signed char __a) {
18899 #ifdef __LITTLE_ENDIAN__
18900  return __builtin_altivec_vstribr_p(__CR6_EQ, __a);
18901 #else
18902  return __builtin_altivec_vstribl_p(__CR6_EQ, __a);
18903 #endif
18904 }
18905 
18906 static __inline__ int __ATTRS_o_ai vec_stril_p(vector unsigned short __a) {
18907 #ifdef __LITTLE_ENDIAN__
18908  return __builtin_altivec_vstrihr_p(__CR6_EQ, (vector signed short)__a);
18909 #else
18910  return __builtin_altivec_vstrihl_p(__CR6_EQ, (vector signed short)__a);
18911 #endif
18912 }
18913 
18914 static __inline__ int __ATTRS_o_ai vec_stril_p(vector signed short __a) {
18915 #ifdef __LITTLE_ENDIAN__
18916  return __builtin_altivec_vstrihr_p(__CR6_EQ, __a);
18917 #else
18918  return __builtin_altivec_vstrihl_p(__CR6_EQ, __a);
18919 #endif
18920 }
18921 
18922 /* vec_strir */
18923 
18924 static __inline__ vector unsigned char __ATTRS_o_ai
18925 vec_strir(vector unsigned char __a) {
18926 #ifdef __LITTLE_ENDIAN__
18927  return __builtin_altivec_vstribl((vector signed char)__a);
18928 #else
18929  return __builtin_altivec_vstribr((vector signed char)__a);
18930 #endif
18931 }
18932 
18933 static __inline__ vector signed char __ATTRS_o_ai
18934 vec_strir(vector signed char __a) {
18935 #ifdef __LITTLE_ENDIAN__
18936  return __builtin_altivec_vstribl(__a);
18937 #else
18938  return __builtin_altivec_vstribr(__a);
18939 #endif
18940 }
18941 
18942 static __inline__ vector unsigned short __ATTRS_o_ai
18943 vec_strir(vector unsigned short __a) {
18944 #ifdef __LITTLE_ENDIAN__
18945  return __builtin_altivec_vstrihl((vector signed short)__a);
18946 #else
18947  return __builtin_altivec_vstrihr((vector signed short)__a);
18948 #endif
18949 }
18950 
18951 static __inline__ vector signed short __ATTRS_o_ai
18952 vec_strir(vector signed short __a) {
18953 #ifdef __LITTLE_ENDIAN__
18954  return __builtin_altivec_vstrihl(__a);
18955 #else
18956  return __builtin_altivec_vstrihr(__a);
18957 #endif
18958 }
18959 
18960 /* vec_strir_p */
18961 
18962 static __inline__ int __ATTRS_o_ai vec_strir_p(vector unsigned char __a) {
18963 #ifdef __LITTLE_ENDIAN__
18964  return __builtin_altivec_vstribl_p(__CR6_EQ, (vector signed char)__a);
18965 #else
18966  return __builtin_altivec_vstribr_p(__CR6_EQ, (vector signed char)__a);
18967 #endif
18968 }
18969 
18970 static __inline__ int __ATTRS_o_ai vec_strir_p(vector signed char __a) {
18971 #ifdef __LITTLE_ENDIAN__
18972  return __builtin_altivec_vstribl_p(__CR6_EQ, __a);
18973 #else
18974  return __builtin_altivec_vstribr_p(__CR6_EQ, __a);
18975 #endif
18976 }
18977 
18978 static __inline__ int __ATTRS_o_ai vec_strir_p(vector unsigned short __a) {
18979 #ifdef __LITTLE_ENDIAN__
18980  return __builtin_altivec_vstrihl_p(__CR6_EQ, (vector signed short)__a);
18981 #else
18982  return __builtin_altivec_vstrihr_p(__CR6_EQ, (vector signed short)__a);
18983 #endif
18984 }
18985 
18986 static __inline__ int __ATTRS_o_ai vec_strir_p(vector signed short __a) {
18987 #ifdef __LITTLE_ENDIAN__
18988  return __builtin_altivec_vstrihl_p(__CR6_EQ, __a);
18989 #else
18990  return __builtin_altivec_vstrihr_p(__CR6_EQ, __a);
18991 #endif
18992 }
18993 
18994 /* vs[l | r | ra] */
18995 
18996 #ifdef __SIZEOF_INT128__
18997 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18998 vec_sl(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18999  return __a << (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19000  __CHAR_BIT__));
19001 }
19002 
19003 static __inline__ vector signed __int128 __ATTRS_o_ai
19004 vec_sl(vector signed __int128 __a, vector unsigned __int128 __b) {
19005  return __a << (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19006  __CHAR_BIT__));
19007 }
19008 
19009 static __inline__ vector unsigned __int128 __ATTRS_o_ai
19010 vec_sr(vector unsigned __int128 __a, vector unsigned __int128 __b) {
19011  return __a >> (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19012  __CHAR_BIT__));
19013 }
19014 
19015 static __inline__ vector signed __int128 __ATTRS_o_ai
19016 vec_sr(vector signed __int128 __a, vector unsigned __int128 __b) {
19017  return (
19018  vector signed __int128)(((vector unsigned __int128)__a) >>
19019  (__b %
19020  (vector unsigned __int128)(sizeof(
19021  unsigned __int128) *
19022  __CHAR_BIT__)));
19023 }
19024 
19025 static __inline__ vector unsigned __int128 __ATTRS_o_ai
19026 vec_sra(vector unsigned __int128 __a, vector unsigned __int128 __b) {
19027  return (
19028  vector unsigned __int128)(((vector signed __int128)__a) >>
19029  (__b %
19030  (vector unsigned __int128)(sizeof(
19031  unsigned __int128) *
19032  __CHAR_BIT__)));
19033 }
19034 
19035 static __inline__ vector signed __int128 __ATTRS_o_ai
19036 vec_sra(vector signed __int128 __a, vector unsigned __int128 __b) {
19037  return __a >> (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19038  __CHAR_BIT__));
19039 }
19040 
19041 #endif /* __SIZEOF_INT128__ */
19042 #endif /* __POWER10_VECTOR__ */
19043 
19044 #ifdef __POWER8_VECTOR__
19045 #define __bcdadd(__a, __b, __ps) __builtin_ppc_bcdadd((__a), (__b), (__ps))
19046 #define __bcdsub(__a, __b, __ps) __builtin_ppc_bcdsub((__a), (__b), (__ps))
19047 
19048 static __inline__ long __bcdadd_ofl(vector unsigned char __a,
19049  vector unsigned char __b) {
19050  return __builtin_ppc_bcdadd_p(__CR6_SO, __a, __b);
19051 }
19052 
19053 static __inline__ long __bcdsub_ofl(vector unsigned char __a,
19054  vector unsigned char __b) {
19055  return __builtin_ppc_bcdsub_p(__CR6_SO, __a, __b);
19056 }
19057 
19058 static __inline__ long __bcd_invalid(vector unsigned char __a) {
19059  return __builtin_ppc_bcdsub_p(__CR6_SO, __a, __a);
19060 }
19061 
19062 static __inline__ long __bcdcmpeq(vector unsigned char __a,
19063  vector unsigned char __b) {
19064  return __builtin_ppc_bcdsub_p(__CR6_EQ, __a, __b);
19065 }
19066 
19067 static __inline__ long __bcdcmplt(vector unsigned char __a,
19068  vector unsigned char __b) {
19069  return __builtin_ppc_bcdsub_p(__CR6_LT, __a, __b);
19070 }
19071 
19072 static __inline__ long __bcdcmpgt(vector unsigned char __a,
19073  vector unsigned char __b) {
19074  return __builtin_ppc_bcdsub_p(__CR6_GT, __a, __b);
19075 }
19076 
19077 static __inline__ long __bcdcmple(vector unsigned char __a,
19078  vector unsigned char __b) {
19079  return __builtin_ppc_bcdsub_p(__CR6_GT_REV, __a, __b);
19080 }
19081 
19082 static __inline__ long __bcdcmpge(vector unsigned char __a,
19083  vector unsigned char __b) {
19084  return __builtin_ppc_bcdsub_p(__CR6_LT_REV, __a, __b);
19085 }
19086 
19087 #endif // __POWER8_VECTOR__
19088 
19089 #undef __ATTRS_o_ai
19090 
19091 #endif /* __ALTIVEC_H */
vec_vsubshs
static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a, vector short __b)
Definition: altivec.h:12218
vec_any_ngt
static __inline__ int __ATTRS_o_ai vec_any_ngt(vector float __a, vector float __b)
Definition: altivec.h:17161
vec_vsubuws
static __inline__ vector unsigned int __ATTRS_o_ai vec_vsubuws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:12270
vec_cmple
static __inline__ vector bool char __ATTRS_o_ai vec_cmple(vector signed char __a, vector signed char __b)
Definition: altivec.h:2355
vec_vsrb
static __inline__ vector signed char __ATTRS_o_ai vec_vsrb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:10433
vec_vsubsws
static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a, vector int __b)
Definition: altivec.h:12252
vec_vadduhs
static __inline__ vector unsigned short __ATTRS_o_ai vec_vadduhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:760
vec_st
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b, vector signed char *__c)
Definition: altivec.h:11130
__CR6_GT
#define __CR6_GT
Definition: altivec.h:22
__CR6_LT_REV
#define __CR6_LT_REV
Definition: altivec.h:21
vec_round
static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a)
Definition: altivec.h:8415
vec_unpackl
static __inline__ vector short __ATTRS_o_ai vec_unpackl(vector signed char __a)
Definition: altivec.h:12712
vec_vsrh
static __inline__ vector short __ATTRS_o_ai vec_vsrh(vector short __a, vector unsigned short __b)
Definition: altivec.h:10447
vec_stvxl
static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:11681
vec_vspltisb
static __inline__ vector signed char __ATTRS_o_ai vec_vspltisb(signed char __a)
Definition: altivec.h:10274
vec_vupklsh
static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a)
Definition: altivec.h:12801
vec_sll
static __inline__ vector signed char __ATTRS_o_ai vec_sll(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9470
vec_ste
static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, long __b, signed char *__c)
Definition: altivec.h:11393
vec_vpkshus
static __inline__ vector unsigned char __ATTRS_o_ai vec_vpkshus(vector short __a, vector short __b)
Definition: altivec.h:7857
vec_splat_s16
static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a)
Definition: altivec.h:10283
vec_vadduws
static __inline__ vector unsigned int __ATTRS_o_ai vec_vadduws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:794
vec_any_nge
static __inline__ int __ATTRS_o_ai vec_any_nge(vector float __a, vector float __b)
Definition: altivec.h:17143
vec_vslw
static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a, vector unsigned int __b)
Definition: altivec.h:8951
vec_vsubuhm
static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a, vector short __b)
Definition: altivec.h:11978
vec_and
static __inline__ vector signed char __ATTRS_o_ai vec_and(vector signed char __a, vector signed char __b)
Definition: altivec.h:868
vec_packsu
static __inline__ vector unsigned char __ATTRS_o_ai vec_packsu(vector short __a, vector short __b)
Definition: altivec.h:7799
NULL
#define NULL
Definition: stddef.h:89
vec_all_numeric
static __inline__ int __ATTRS_o_ai vec_all_numeric(vector float __a)
Definition: altivec.h:15942
vec_msum
static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a, vector unsigned char __b, vector int __c)
Definition: altivec.h:6014
vec_recipdiv
static vector float __ATTRS_o_ai vec_recipdiv(vector float __a, vector float __b)
Definition: altivec.h:18187
vec_mulo
static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a, vector signed char __b)
Definition: altivec.h:6364
vec_cmpne
static __inline__ vector bool char __ATTRS_o_ai vec_cmpne(vector bool char __a, vector bool char __b)
Definition: altivec.h:2016
vec_vsububm
static __inline__ vector signed char __ATTRS_o_ai vec_vsububm(vector signed char __a, vector signed char __b)
Definition: altivec.h:11945
vec_vandc
static __inline__ vector signed char __ATTRS_o_ai vec_vandc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1407
vec_all_eq
static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:14714
vec_mladd
static __inline__ vector signed short __ATTRS_o_ai vec_mladd(vector signed short, vector signed short, vector signed short)
vec_sro
static __inline__ vector signed char __ATTRS_o_ai vec_sro(vector signed char __a, vector signed char __b)
Definition: altivec.h:10925
int
__device__ int
Definition: __clang_hip_libdevice_declares.h:63
vec_rl
static __inline__ vector signed char __ATTRS_o_ai vec_rl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8242
vec_vsr
static __inline__ vector signed char __ATTRS_o_ai vec_vsr(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:10752
vec_lvewx
static __inline__ vector int __ATTRS_o_ai vec_lvewx(long __a, const int *__b)
Definition: altivec.h:4251
vec_xst
static __ATTRS_o_ai void vec_xst(vector signed char __vec, ptrdiff_t __offset, signed char *__ptr)
Definition: altivec.h:17889
vec_sube
static __inline__ vector signed int __ATTRS_o_ai vec_sube(vector signed int __a, vector signed int __b, vector signed int __c)
Definition: altivec.h:12402
vec_vminuw
static __inline__ vector unsigned int __ATTRS_o_ai vec_vminuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:5922
__a
static __inline__ void int __a
Definition: emmintrin.h:4189
vec_any_lt
static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:16733
vec_any_eq
static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:15958
vec_vnor
static __inline__ vector signed char __ATTRS_o_ai vec_vnor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6747
vec_add
static __inline__ vector signed char __ATTRS_o_ai vec_add(vector signed char __a, vector signed char __b)
Definition: altivec.h:200
vec_adds
static __inline__ vector signed char __ATTRS_o_ai vec_adds(vector signed char __a, vector signed char __b)
Definition: altivec.h:617
vec_unsigned
static __inline__ vector unsigned int __ATTRS_o_ai vec_unsigned(vector float __a)
Definition: altivec.h:3492
vec_vmaxub
static __inline__ vector unsigned char __ATTRS_o_ai vec_vmaxub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:4950
vec_mul
static __inline__ vector signed char __ATTRS_o_ai vec_mul(vector signed char __a, vector signed char __b)
Definition: altivec.h:6160
vec_nor
static __inline__ vector signed char __ATTRS_o_ai vec_nor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6684
vec_vadduwm
static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a, vector int __b)
Definition: altivec.h:535
vec_stvewx
static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, long __b, int *__c)
Definition: altivec.h:11523
vec_vsplth
static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a, unsigned char __b)
Definition: altivec.h:10184
vec_ld
static __inline__ vector signed char __ATTRS_o_ai vec_ld(long __a, const vector signed char *__b)
Definition: altivec.h:4016
vec_vadduhm
static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a, vector short __b)
Definition: altivec.h:501
__CR6_LT
#define __CR6_LT
Definition: altivec.h:20
vec_mergel
static __inline__ vector signed char __ATTRS_o_ai vec_mergel(vector signed char __a, vector signed char __b)
Definition: altivec.h:5316
vec_vperm
static __inline__ vector signed char __ATTRS_o_ai vec_vperm(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:8139
vec_nabs
static vector float __ATTRS_o_ai vec_nabs(vector float __a)
Definition: altivec.h:18158
vec_vsububs
static __inline__ vector unsigned char __ATTRS_o_ai vec_vsububs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:12202
vec_vaddshs
static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a, vector short __b)
Definition: altivec.h:742
vec_div
static __inline__ vector signed char __ATTRS_o_ai vec_div(vector signed char __a, vector signed char __b)
Definition: altivec.h:3739
vec_sra
static __inline__ vector signed char __ATTRS_o_ai vec_sra(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:10473
vec_sl
static __inline__ vector unsigned char __ATTRS_o_ai vec_sl(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:8828
vec_all_ge
static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:14919
vec_any_nlt
static __inline__ int __ATTRS_o_ai vec_any_nlt(vector float __a, vector float __b)
Definition: altivec.h:17197
vec_vmrghw
static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a, vector int __b)
Definition: altivec.h:5281
vec_vsel
static __inline__ vector signed char __ATTRS_o_ai vec_vsel(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:8708
vec_subc
static __inline__ vector signed int __ATTRS_o_ai vec_subc(vector signed int __a, vector signed int __b)
Definition: altivec.h:12054
vec_splat
static __inline__ vector signed char __ATTRS_o_ai vec_splat(vector signed char __a, unsigned const int __b)
Definition: altivec.h:10036
vec_xor
static __inline__ vector unsigned char __ATTRS_o_ai vec_xor(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:13138
vec_sld
static __inline__ vector signed int __ATTRS_o_ai vec_sld(vector signed int, vector signed int, unsigned const int __c)
Definition: altivec.h:9095
vec_vslh
static __inline__ vector short __ATTRS_o_ai vec_vslh(vector short __a, vector unsigned short __b)
Definition: altivec.h:8938
vec_or
static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a, vector signed char __b)
Definition: altivec.h:6820
vec_cmplt
static __inline__ vector bool char __ATTRS_o_ai vec_cmplt(vector signed char __a, vector signed char __b)
Definition: altivec.h:2421
vec_vaddubm
static __inline__ vector signed char __ATTRS_o_ai vec_vaddubm(vector signed char __a, vector signed char __b)
Definition: altivec.h:468
vec_mtvscr
static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a)
Definition: altivec.h:6109
vec_vmrglw
static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a, vector int __b)
Definition: altivec.h:5544
vec_vminsb
static __inline__ vector signed char __ATTRS_o_ai vec_vminsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:5837
vec_insert
static __inline__ vector signed char __ATTRS_o_ai vec_insert(signed char __a, vector signed char __b, int __c)
Definition: altivec.h:13599
vec_lvrxl
static __inline__ vector signed char __ATTRS_o_ai vec_lvrxl(int __a, const signed char *__b)
Definition: altivec.h:14008
vec_lde
static __inline__ vector signed char __ATTRS_o_ai vec_lde(long __a, const signed char *__b)
Definition: altivec.h:4194
vec_sldw
static __inline__ vector signed char __ATTRS_o_ai vec_sldw(vector signed char __a, vector signed char __b, unsigned const int __c)
Definition: altivec.h:9247
vec_rsqrte
static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a)
Definition: altivec.h:8487
vec_slo
static __inline__ vector signed char __ATTRS_o_ai vec_slo(vector signed char __a, vector signed char __b)
Definition: altivec.h:9830
vec_cmpge
static __inline__ vector bool char __ATTRS_o_ai vec_cmpge(vector signed char __a, vector signed char __b)
Definition: altivec.h:2229
vec_madd
static __inline__ vector signed short __ATTRS_o_ai vec_madd(vector signed short __a, vector signed short __b, vector signed short __c)
Definition: altivec.h:4711
vec_float
static __inline__ vector float __ATTRS_o_ai vec_float(vector signed int __a)
Definition: altivec.h:3534
vec_all_gt
static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:15099
vec_vmrglh
static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a, vector short __b)
Definition: altivec.h:5508
vec_any_ne
static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:16938
__CR6_EQ_REV
#define __CR6_EQ_REV
Definition: altivec.h:19
vec_vor
static __inline__ vector signed char __ATTRS_o_ai vec_vor(vector signed char __a, vector signed char __b)
Definition: altivec.h:7176
vec_vminsw
static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a, vector int __b)
Definition: altivec.h:5904
vec_lvsl
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const signed char *__b)
Definition: altivec.h:4473
vec_floor
static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a)
Definition: altivec.h:3981
vec_vmaxuh
static __inline__ vector unsigned short __ATTRS_o_ai vec_vmaxuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:4984
vec_vaddubs
static __inline__ vector unsigned char __ATTRS_o_ai vec_vaddubs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:726
vec_any_ge
static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:16163
vec_ldl
static __inline__ vector signed char __ATTRS_o_ai vec_ldl(long __a, const vector signed char *__b)
Definition: altivec.h:4268
vec_vpkuhum
static __inline__ vector signed char __ATTRS_o_ai vec_vpkuhum(vector signed short __a, vector signed short __b)
Definition: altivec.h:7502
vec_signed
static __inline__ vector signed int __ATTRS_o_ai vec_signed(vector float __a)
Definition: altivec.h:3450
vec_cmpeq
static __inline__ vector bool char __ATTRS_o_ai vec_cmpeq(vector signed char __a, vector signed char __b)
Definition: altivec.h:1694
double
__device__ double
Definition: __clang_hip_libdevice_declares.h:165
vec_splat_s8
static __inline__ vector signed char __ATTRS_o_ai vec_splat_s8(signed char __a)
Definition: altivec.h:10266
vec_splats
static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a)
Definition: altivec.h:14649
vec_all_nge
static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a, vector float __b)
Definition: altivec.h:15869
__attribute__
vector signed char unaligned_vec_schar __attribute__((aligned(1)))
Definition: altivec.h:17610
vec_lvebx
static __inline__ vector signed char __ATTRS_o_ai vec_lvebx(long __a, const signed char *__b)
Definition: altivec.h:4228
vec_subs
static __inline__ vector signed char __ATTRS_o_ai vec_subs(vector signed char __a, vector signed char __b)
Definition: altivec.h:12093
vec_vminub
static __inline__ vector unsigned char __ATTRS_o_ai vec_vminub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:5854
vec_vspltw
static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a, unsigned char __b)
Definition: altivec.h:10224
vec_vmladduhm
static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a, vector short __b, vector short __c)
Definition: altivec.h:5976
vec_all_nlt
static __inline__ int __ATTRS_o_ai vec_all_nlt(vector float __a, vector float __b)
Definition: altivec.h:15924
vec_vmaxsb
static __inline__ vector signed char __ATTRS_o_ai vec_vmaxsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4933
vec_any_nan
static __inline__ int __ATTRS_o_ai vec_any_nan(vector float __a)
Definition: altivec.h:16923
vec_vslo
static __inline__ vector signed char __ATTRS_o_ai vec_vslo(vector signed char __a, vector signed char __b)
Definition: altivec.h:9946
vec_stvrxl
static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:14462
vec_xl_be
#define vec_xl_be
Definition: altivec.h:17774
vec_andc
static __inline__ vector signed char __ATTRS_o_ai vec_andc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1221
vec_splat_u32
static __inline__ vector unsigned int __ATTRS_o_ai vec_splat_u32(signed char __a)
Definition: altivec.h:10330
vec_any_gt
static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:16353
vec_perm
static __inline__ vector signed char __ATTRS_o_ai vec_perm(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:7917
vec_vsubuwm
static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a, vector int __b)
Definition: altivec.h:12012
vec_vmaxsh
static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a, vector short __b)
Definition: altivec.h:4966
vec_pack
static __inline__ vector signed char __ATTRS_o_ai vec_pack(vector signed short __a, vector signed short __b)
Definition: altivec.h:7344
vec_re
static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a)
Definition: altivec.h:8218
vec_vpkswus
static __inline__ vector unsigned short __ATTRS_o_ai vec_vpkswus(vector int __a, vector int __b)
Definition: altivec.h:7877
vec_vsrab
static __inline__ vector signed char __ATTRS_o_ai vec_vsrab(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:10529
vec_stvlx
static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:14113
vec_sub
static __inline__ vector signed char __ATTRS_o_ai vec_sub(vector signed char __a, vector signed char __b)
Definition: altivec.h:11815
vec_vsl
static __inline__ vector signed char __ATTRS_o_ai vec_vsl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9657
vec_roundm
static __inline__ vector float __ATTRS_o_ai vec_roundm(vector float __a)
Definition: altivec.h:3996
vec_nmsub
static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a, vector float __b, vector float __c)
Definition: altivec.h:6654
vec_all_ne
static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:15664
vec_all_lt
static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:15467
vec_vsraw
static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a, vector unsigned int __b)
Definition: altivec.h:10552
vec_max
static __inline__ vector signed char __ATTRS_o_ai vec_max(vector signed char __a, vector signed char __b)
Definition: altivec.h:4793
vec_vminuh
static __inline__ vector unsigned short __ATTRS_o_ai vec_vminuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:5888
vec_vmrglb
static __inline__ vector signed char __ATTRS_o_ai vec_vmrglb(vector signed char __a, vector signed char __b)
Definition: altivec.h:5481
vec_avg
static __inline__ vector signed char __ATTRS_o_ai vec_avg(vector signed char __a, vector signed char __b)
Definition: altivec.h:1572
vec_neg
static vector float __ATTRS_o_ai vec_neg(vector float __a)
Definition: altivec.h:18129
vec_lvlx
static __inline__ vector signed char __ATTRS_o_ai vec_lvlx(int __a, const signed char *__b)
Definition: altivec.h:13690
vec_vminsh
static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a, vector short __b)
Definition: altivec.h:5870
vec_vupklsb
static __inline__ vector short __ATTRS_o_ai vec_vupklsb(vector signed char __a)
Definition: altivec.h:12782
vec_stvlxl
static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:14229
vec_splat_s32
static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a)
Definition: altivec.h:10299
vec_vmrghh
static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a, vector short __b)
Definition: altivec.h:5245
vec_addc
static __inline__ vector signed int __ATTRS_o_ai vec_addc(vector signed int __a, vector signed int __b)
Definition: altivec.h:577
vec_unpackh
static __inline__ vector short __ATTRS_o_ai vec_unpackh(vector signed char __a)
Definition: altivec.h:12573
vec_abs
static __inline__ vector signed char __ATTRS_o_ai vec_abs(vector signed char __a)
Definition: altivec.h:117
vec_roundp
static __inline__ vector float __ATTRS_o_ai vec_roundp(vector float __a)
Definition: altivec.h:1660
vec_vsro
static __inline__ vector signed char __ATTRS_o_ai vec_vsro(vector signed char __a, vector signed char __b)
Definition: altivec.h:11041
vec_mule
static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a, vector signed char __b)
Definition: altivec.h:6218
vec_vspltish
static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a)
Definition: altivec.h:10290
vec_vspltisw
static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a)
Definition: altivec.h:10306
vec_vxor
static __inline__ vector signed char __ATTRS_o_ai vec_vxor(vector signed char __a, vector signed char __b)
Definition: altivec.h:13306
vec_extract
static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a, signed int __b)
Definition: altivec.h:13472
vec_stvehx
static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, long __b, short *__c)
Definition: altivec.h:11491
vec_lvehx
static __inline__ vector short __ATTRS_o_ai vec_lvehx(long __a, const short *__b)
Definition: altivec.h:4239
vec_lvrx
static __inline__ vector signed char __ATTRS_o_ai vec_lvrx(int __a, const signed char *__b)
Definition: altivec.h:13902
vec_vmrghb
static __inline__ vector signed char __ATTRS_o_ai vec_vmrghb(vector signed char __a, vector signed char __b)
Definition: altivec.h:5218
vec_vsldoi
static __inline__ vector signed char __ATTRS_o_ai vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c)
Definition: altivec.h:9320
vec_lvlxl
static __inline__ vector signed char __ATTRS_o_ai vec_lvlxl(int __a, const signed char *__b)
Definition: altivec.h:13796
vec_vrlw
static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a, vector unsigned int __b)
Definition: altivec.h:8403
vec_promote
static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a, int __b)
Definition: altivec.h:14579
vec_min
static __inline__ vector signed char __ATTRS_o_ai vec_min(vector signed char __a, vector signed char __b)
Definition: altivec.h:5697
ptrdiff_t
__PTRDIFF_TYPE__ ptrdiff_t
A signed integer type that is the result of subtracting two pointers.
Definition: opencl-c-base.h:124
vec_vrlb
static __inline__ vector signed char __ATTRS_o_ai vec_vrlb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8380
vec_vaddsbs
static __inline__ vector signed char __ATTRS_o_ai vec_vaddsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:709
__CR6_EQ
#define __CR6_EQ
Definition: altivec.h:18
__ATTRS_o_ai
#define __ATTRS_o_ai
Definition: altivec.h:46
vec_vmaxsw
static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a, vector int __b)
Definition: altivec.h:5000
vec_all_nle
static __inline__ int __ATTRS_o_ai vec_all_nle(vector float __a, vector float __b)
Definition: altivec.h:15906
vec_vsrah
static __inline__ vector short __ATTRS_o_ai vec_vsrah(vector short __a, vector unsigned short __b)
Definition: altivec.h:10541
vec_vslb
static __inline__ vector signed char __ATTRS_o_ai vec_vslb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8924
vec_roundz
static __inline__ vector float __ATTRS_o_ai vec_roundz(vector float __a)
Definition: altivec.h:12543
__CR6_GT_REV
#define __CR6_GT_REV
Definition: altivec.h:23
vec_vpkuwum
static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a, vector int __b)
Definition: altivec.h:7550
vec_cmpgt
static __inline__ vector bool char __ATTRS_o_ai vec_cmpgt(vector signed char __a, vector signed char __b)
Definition: altivec.h:2115
__b
static __inline__ vector float vector float __b
Definition: altivec.h:570
vec_vspltb
static __inline__ vector signed char __ATTRS_o_ai vec_vspltb(vector signed char __a, unsigned char __b)
Definition: altivec.h:10166
vec_vupkhsh
static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a)
Definition: altivec.h:12662
vec_splat_u8
static __inline__ vector unsigned char __ATTRS_o_ai vec_splat_u8(unsigned char __a)
Definition: altivec.h:10314
vec_splat_u16
static __inline__ vector unsigned short __ATTRS_o_ai vec_splat_u16(signed char __a)
Definition: altivec.h:10322
vec_any_nle
static __inline__ int __ATTRS_o_ai vec_any_nle(vector float __a, vector float __b)
Definition: altivec.h:17179
vec_stvx
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b, vector signed char *__c)
Definition: altivec.h:11261
vec_srl
static __inline__ vector signed char __ATTRS_o_ai vec_srl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:10565
vec_vmaxuw
static __inline__ vector unsigned int __ATTRS_o_ai vec_vmaxuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:5018
vec_vupkhsb
static __inline__ vector short __ATTRS_o_ai vec_vupkhsb(vector signed char __a)
Definition: altivec.h:12643
vec_sum4s
static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a, vector int __b)
Definition: altivec.h:12418
vec_all_le
static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:15286
vec_xst_be
#define vec_xst_be
Definition: altivec.h:18115
vec_stl
static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:11550
vec_stvebx
static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, long __b, signed char *__c)
Definition: altivec.h:11469
vec_ceil
static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a)
Definition: altivec.h:1645
vec_lvx
static __inline__ vector signed char __ATTRS_o_ai vec_lvx(long __a, const vector signed char *__b)
Definition: altivec.h:4105
__c
static __inline__ vector float vector float vector float __c
Definition: altivec.h:4755
vec_trunc
static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a)
Definition: altivec.h:12528
vec_stvrx
static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:14346
vec_vrlh
static __inline__ vector short __ATTRS_o_ai vec_vrlh(vector short __a, vector unsigned short __b)
Definition: altivec.h:8392
vec_vsrw
static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a, vector unsigned int __b)
Definition: altivec.h:10460
float
__device__ float
Definition: __clang_hip_libdevice_declares.h:22
vec_adde
static __inline__ vector signed int __ATTRS_o_ai vec_adde(vector signed int __a, vector signed int __b, vector signed int __c)
Definition: altivec.h:379
vec_xl
static __ATTRS_o_ai vector signed char vec_xl(ptrdiff_t __offset, const signed char *__ptr)
Definition: altivec.h:17618
stddef.h
__CR6_SO
#define __CR6_SO
Definition: altivec.h:24
vec_lvsr
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a, const signed char *__b)
Definition: altivec.h:4594
vec_vaddsws
static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a, vector int __b)
Definition: altivec.h:776
vec_vand
static __inline__ vector signed char __ATTRS_o_ai vec_vand(vector signed char __a, vector signed char __b)
Definition: altivec.h:1054
vec_revb
static __inline__ vector bool char __ATTRS_o_ai vec_revb(vector bool char __a)
Definition: altivec.h:17492
vec_vsubuhs
static __inline__ vector unsigned short __ATTRS_o_ai vec_vsubuhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:12236
vec_sel
static __inline__ vector signed char __ATTRS_o_ai vec_sel(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:8534
vec_vsubsbs
static __inline__ vector signed char __ATTRS_o_ai vec_vsubsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:12185
vec_all_ngt
static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a, vector float __b)
Definition: altivec.h:15887
vec_msums
static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a, vector short __b, vector int __c)
Definition: altivec.h:6080
vec_rsqrt
static vector float __ATTRS_o_ai vec_rsqrt(vector float __a)
Definition: altivec.h:8501
vec_any_le
static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:16543
vec_reve
static __ATTRS_o_ai vector bool char vec_reve(vector bool char __a)
Definition: altivec.h:17422
vec_packs
static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a, vector short __b)
Definition: altivec.h:7670
vec_mergeh
static __inline__ vector signed char __ATTRS_o_ai vec_mergeh(vector signed char __a, vector signed char __b)
Definition: altivec.h:5046
vec_lvxl
static __inline__ vector signed char __ATTRS_o_ai vec_lvxl(long __a, const vector signed char *__b)
Definition: altivec.h:4357
vec_abss
static __inline__ vector signed char __ATTRS_o_ai vec_abss(vector signed char __a)
Definition: altivec.h:160
vec_any_numeric
static __inline__ int __ATTRS_o_ai vec_any_numeric(vector float __a)
Definition: altivec.h:17215
vec_sr
static __inline__ vector unsigned char __ATTRS_o_ai vec_sr(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:10339
vec_all_nan
static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a)
Definition: altivec.h:15648
Generated on Mon Apr 4 2022 01:35:33 for clang by   doxygen 1.8.17